diff --git a/apps/host-daemon/src/injected-skills.test.ts b/apps/host-daemon/src/injected-skills.test.ts index 9baf60bb1..4c557d8a6 100644 --- a/apps/host-daemon/src/injected-skills.test.ts +++ b/apps/host-daemon/src/injected-skills.test.ts @@ -166,6 +166,51 @@ describe("injected skill staging", () => { }); }); + it("stages built-in skill sources into the shared catalog", async () => { + const dataDir = await makeTempDir(); + const bundledRoot = await makeTempDir(); + const skillRootPath = await writeSkill({ + rootPath: bundledRoot, + name: "building-bb-apps", + }); + + const staged = await stageInjectedSkillSources({ + dataDir, + injectedSkillSources: [ + { + sourceType: "builtin", + applicationId: null, + name: "building-bb-apps", + description: "Use building-bb-apps when host staging tests run.", + sourceRootPath: skillRootPath, + skillFilePath: path.join(skillRootPath, "SKILL.md"), + }, + ], + }); + + const claudeRoot = staged.skillRoots.find(isClaudeCodeSkillRoot); + if (!claudeRoot) { + throw new Error("Expected Claude Code skill root"); + } + expect(claudeRoot.skillNames).toEqual(["building-bb-apps"]); + await expect( + readFile( + path.join(claudeRoot.localPluginPath, "catalog.json"), + "utf8", + ).then((content) => JSON.parse(content)), + ).resolves.toMatchObject({ + catalogHash: staged.catalogHash, + skills: [ + { + applicationId: null, + name: "building-bb-apps", + sourceRootPath: skillRootPath, + sourceType: "builtin", + }, + ], + }); + }); + it("changes the catalog hash when skill content changes", async () => { const dataDir = await makeTempDir(); const sourceRootPath = path.join(dataDir, "source-skills"); diff --git a/apps/server/package.json b/apps/server/package.json index 41f1602d7..2c764b3b0 100644 --- a/apps/server/package.json +++ b/apps/server/package.json @@ -4,7 +4,7 @@ "type": "module", "private": true, "scripts": { - "build": "node ../../scripts/build-node-entry.mjs src/index.ts dist/index.js --clean-dist --templates --external ./start-server.js --copy-dir ../../packages/db/drizzle dist/drizzle && node --import tsx scripts/copy-app-scaffold-template.ts && node ../../scripts/build-node-entry.mjs src/start-server.ts dist/start-server.js", + "build": "node ../../scripts/build-node-entry.mjs src/index.ts dist/index.js --clean-dist --templates --external ./start-server.js --copy-dir ../../packages/db/drizzle dist/drizzle && node --import tsx scripts/copy-app-scaffold-template.ts && node --import tsx scripts/copy-builtin-skills.ts && node ../../scripts/build-node-entry.mjs src/start-server.ts dist/start-server.js", "bench": "vitest bench --config vitest.config.ts", "build:app-scaffold-template": "node ./scripts/build-app-scaffold-template.mjs", "start": "node dist/index.js", diff --git a/apps/server/scripts/copy-builtin-skills.ts b/apps/server/scripts/copy-builtin-skills.ts new file mode 100644 index 000000000..6caafe34f --- /dev/null +++ b/apps/server/scripts/copy-builtin-skills.ts @@ -0,0 +1,22 @@ +import { rm } from "node:fs/promises"; +import path from "node:path"; +import { fileURLToPath } from "node:url"; +import { + BUILTIN_SKILLS_DIRECTORY_NAME, + copyBuiltinSkills, + resolveBuiltinSkillsRootPath, +} from "../src/services/skills/builtin-skills-copy.js"; + +// Build step: copies the built-in injected skills into dist so the bundled +// server resolves them beside its dist entry points, mirroring the app +// scaffold template copy. +const scriptDir = path.dirname(fileURLToPath(import.meta.url)); +const targetPath = path.resolve( + scriptDir, + "../dist", + BUILTIN_SKILLS_DIRECTORY_NAME, +); + +const skillsRootPath = resolveBuiltinSkillsRootPath(); +await rm(targetPath, { force: true, recursive: true }); +await copyBuiltinSkills({ skillsRootPath, targetPath }); diff --git a/apps/server/src/services/skills/builtin-skills-copy.ts b/apps/server/src/services/skills/builtin-skills-copy.ts new file mode 100644 index 000000000..fafe86a10 --- /dev/null +++ b/apps/server/src/services/skills/builtin-skills-copy.ts @@ -0,0 +1,72 @@ +import { cp } from "node:fs/promises"; +import { constants as fsConstants, existsSync } from "node:fs"; +import path from "node:path"; +import { fileURLToPath } from "node:url"; + +/** + * Locates and copies the built-in skills that ship beside this module. + * + * This module is shared between the server runtime (built-in injected skill + * discovery in ./injected-skills.ts) and the build step that copies the + * skills into dist (scripts/copy-builtin-skills.ts, loaded with tsx before + * workspace packages are built). Keep it free of workspace and third-party + * imports. + */ + +interface CopyBuiltinSkillsArgs { + skillsRootPath: string; + targetPath: string; +} + +interface ResolveBuiltinSkillsRootPathArgs { + moduleDir: string; +} + +export const BUILTIN_SKILLS_DIRECTORY_NAME = "builtin-skills"; +// Structural essential the server itself depends on. Skill content may change +// without breaking root detection. +const BUILTIN_SKILLS_SENTINEL_PATH = path.join( + "building-bb-apps", + "SKILL.md", +); +const BUILTIN_SKILLS_COPY_MODE = fsConstants.COPYFILE_FICLONE; +const builtinSkillsModuleDir = path.dirname(fileURLToPath(import.meta.url)); + +function hasBuiltinSkillsRoot(skillsRootPath: string): boolean { + return existsSync(path.join(skillsRootPath, BUILTIN_SKILLS_SENTINEL_PATH)); +} + +/** + * The built-in skills directory sits beside this module in both layouts: + * src/services/skills/ in the source tree, and dist/ in the bundled server + * (the build copies the skills to dist/builtin-skills and esbuild bundles + * this module into the dist entry points). + */ +export function resolveBuiltinSkillsRootPathForModuleDir( + args: ResolveBuiltinSkillsRootPathArgs, +): string { + const skillsRootPath = path.resolve( + args.moduleDir, + BUILTIN_SKILLS_DIRECTORY_NAME, + ); + if (!hasBuiltinSkillsRoot(skillsRootPath)) { + throw new Error(`Missing built-in skills at ${skillsRootPath}`); + } + return skillsRootPath; +} + +export function resolveBuiltinSkillsRootPath(): string { + return resolveBuiltinSkillsRootPathForModuleDir({ + moduleDir: builtinSkillsModuleDir, + }); +} + +export async function copyBuiltinSkills( + args: CopyBuiltinSkillsArgs, +): Promise { + await cp(args.skillsRootPath, args.targetPath, { + force: false, + mode: BUILTIN_SKILLS_COPY_MODE, + recursive: true, + }); +} diff --git a/apps/server/src/services/skills/builtin-skills/building-bb-apps/SKILL.md b/apps/server/src/services/skills/builtin-skills/building-bb-apps/SKILL.md new file mode 100644 index 000000000..9591dbe61 --- /dev/null +++ b/apps/server/src/services/skills/builtin-skills/building-bb-apps/SKILL.md @@ -0,0 +1,479 @@ +--- +name: building-bb-apps +description: Use this when building, modifying, debugging, or authoring data or skills for a bb app, including the app model, window.bb SDK, bb app CLI, capabilities, data storage, app-local skills, and realtime data binding. +--- + +# Building bb Apps + +Use this skill whenever you are creating or changing a bb app. A bb app is a +global, local-host app stored under the bb data directory. It is not a separate +web service. + +## App Model + +A global app lives at: + +```text +/apps// + manifest.json + public/ + data/ + skills/ + source/ +``` + +`` is the application id. `manifest.id` must equal the containing folder +name and must be a lowercase slug up to 64 characters, such as `status` or +`review-board`. +`manifest.name` is display-only. Application ids are identifiers; names are not. + +`public/` is the browser web root. bb serves it at: + +```text +/api/v1/apps// +``` + +The `public/` directory name is not part of the URL. `public/index.html` is +served at `/api/v1/apps//`; `public/index-abc.js` is served at +`/api/v1/apps//index-abc.js`. Use relative asset refs such as +`./index-abc.js`, not root-absolute refs such as `/assets/index-abc.js`. + +`data/` stores durable JSON values addressed by app-data paths. It is private +browser content and is exposed through the SDK, CLI, and server data API. + +`skills/` stores app-local agent skills. Each skill is a normal +`skills//SKILL.md` folder. Valid app-local skills are injected into agents +alongside built-in bb skills and global data-dir skills. + +## Manifest + +Typical manifest: + +```json +{ + "manifestVersion": 1, + "id": "review-board", + "name": "Review Board", + "entry": "index.html", + "capabilities": ["data", "message"] +} +``` + +Allowed capabilities are `data` and `message`. In this Phase 1 prototype, +capabilities are manifest metadata; the injected browser helpers are not gated +by capability. + +`entry` is relative to `public/`. HTML entries get the injected `window.bb` +runtime. Markdown entries render as static documents and do not get +`window.bb`. If `entry` is omitted, bb looks for `index.html` or `index.md`. + +## Create And Build + +Create a scaffolded app with: + +```bash +bb app new --name "Review Board" +bb app new --slug review-board +bb app new --id review-board +``` + +`bb app new` creates a Vite + React + TypeScript Todo app. The generated layout +includes: + +```text +manifest.json +README.md +public/ # prebuilt browser output, served by bb +data/state.json # empty seed JSON object +skills/add-todos/ # app-local skill for writing todo records +source/ # editable Vite React TypeScript project +source/src/bb-sdk.d.ts # generated window.bb types +``` + +The app renders immediately because `public/` is already built. Edit in +`source/`, then rebuild: + +```bash +cd "$BB_APP_ROOT/source" +pnpm install +pnpm build +``` + +The scaffold's Vite config uses: + +```ts +base: "./", +build: { + outDir: "../public", + assetsDir: "", + emptyOutDir: true, +} +``` + +That emits flat, relative assets into `../public`. Rebuild after editing +`source/`; bb serves `public/`, not the Vite dev server. `pnpm dev` is only for +local editing. + +Find an app's canonical filesystem paths with: + +```bash +bb app show review-board --json +bb app current --json +``` + +`bb app current --json` only works inside an app-capable runtime. The runtime +also exposes `BB_APPS_ROOT`, `BB_APP_ID`, `BB_APP_ROOT`, and +`BB_APP_DATA_PATH` when there is a current app. + +## window.bb SDK + +HTML app entries receive `window.bb`. The scaffold vendors generated types at +`source/src/bb-sdk.d.ts`; keep that declaration in sync with `@bb/sdk` when the +SDK contract changes. + +The current-app data API is object-argument based: + +```ts +await window.bb.data.read({ path: "state.json" }); + +await window.bb.data.write({ + path: "todos/todo_20260603_review_notes", + value: { + id: "todo_20260603_review_notes", + title: "Review notes from the manager", + done: false, + createdAt: "2026-06-03T20:00:00.000Z", + updatedAt: "2026-06-03T20:00:00.000Z" + } +}); + +await window.bb.data.delete({ path: "todos/todo_20260603_review_notes" }); + +const rows = await window.bb.data.list({ prefix: "todos" }); +const entries = await window.bb.data.entries({ prefix: "todos" }); +``` + +`read` returns a JSON value or `undefined`. `write` accepts any valid JSON +value. `delete` resolves when the path is removed. `list` returns +`{ path, value }[]`. `entries` returns metadata-bearing entries with `path`, +`value`, `version`, `sizeBytes`, and `modifiedAtMs`. + +`prefix` is optional. `""` matches all app data. A prefix matches either the +exact data path or a subtree under `prefix + "/"`. + +Use `onChange` for live realtime data binding: + +```ts +const unsubscribe = window.bb.data.onChange({ + prefix: "todos", + callback(event) { + console.log(event.path, event.value, event.deleted); + } +}); + +unsubscribe(); +``` + +`onChange({ prefix?, callback })` returns an unsubscribe function. Registering a +listener immediately replays existing matching records, buffers concurrent +events during replay, and replays again after reconnects or app-data resync +hints. Delete events have `deleted: true` and `value: undefined`. +Use this as the canonical reactive binding: browser writes, `bb app data` +writes, server/API writes, observed direct file writes under `data/`, and +deletes converge through this event shape. + +### Realtime Events (bb.on) + +Use `window.bb.on({ event, ...scope, callback })` when an app needs the raw +realtime SDK stream instead of the current-app `data.onChange` adapter. It +returns an idempotent unsubscribe function: + +```ts +const unsubscribeThread = window.bb.on({ + event: "thread:changed", + threadId, + callback(event) { + if (event.changes.includes("status-changed")) { + void reloadThread(); + } + } +}); + +const unsubscribeConnection = window.bb.on({ + event: "realtime:connection", + callback(event) { + if (event.state === "connected" && event.reconnected) { + void reloadThread(); + } + } +}); + +const unsubscribeData = window.bb.data.onChange({ + prefix: "todos", + callback(event) { + renderTodo(event.path, event.value, event.deleted); + } +}); + +unsubscribeThread(); +unsubscribeConnection(); +unsubscribeData(); +``` + +The SDK owns the websocket. It uses one shared websocket per SDK instance, +ref-counts subscriptions, closes the socket when there are no active target +subscriptions, and automatically reconnects and resubscribes active targets. +App authors do not open sockets or send subscribe messages. A +`realtime:connection` listener observes that shared socket but does not open a +socket by itself. + +All `bb.on` inputs include `event` and `callback`; supported scope fields are: + +| Event | Scope fields | Callback receives | +| --- | --- | --- | +| `thread:changed` | `threadId?` | `ChangedMessage` where `entity` is `"thread"`: `{ type: "changed", entity: "thread", id?, metadata?, changes }` | +| `project:changed` | `projectId?` | `ChangedMessage` where `entity` is `"project"`: `{ type: "changed", entity: "project", id?, changes }` | +| `environment:changed` | `environmentId?` | `ChangedMessage` where `entity` is `"environment"`: `{ type: "changed", entity: "environment", id?, changes }` | +| `host:changed` | `hostId?` | `ChangedMessage` where `entity` is `"host"`: `{ type: "changed", entity: "host", id?, changes }` | +| `system:changed` | none | `ChangedMessage` where `entity` is `"system"`: `{ type: "changed", entity: "system", changes }` | +| `system:config-changed` | none | The same system `ChangedMessage`, only when `changes` includes `"config-changed"` | +| `system:apps-changed` | none | The same system `ChangedMessage`, only when `changes` includes `"apps-changed"` | +| `app:changed` | none | `ChangedMessage` where `entity` is `"app"`: `{ type: "changed", entity: "app", id?, changes }` | +| `app-data:changed` | `applicationId?`, `prefix?` | `AppDataBroadcastMessage` with `type: "app-data.changed"`: `{ applicationId, path, value, deleted, version }` | +| `app-data:resync` | `applicationId?` | `AppDataBroadcastMessage` with `type: "app-data.resync"`: `{ applicationId }` | +| `realtime:connection` | none | `{ state: "connecting" | "connected" | "disconnected", reconnected, reconnectDelayMs }` | + +For app data, omit `applicationId` only in a current-app browser context; the +SDK fills it from the injected app context. `prefix` uses the same matching +rules as `window.bb.data.list`: `""` matches everything, otherwise the exact +path or descendants under `prefix + "/"` match. + +Use `window.bb.data.onChange({ prefix?, callback })` for an app's own data in +normal UI code. It is a convenience adapter over +`bb.on({ event: "app-data:changed", applicationId, prefix, callback })`: it +subscribes, replays current matching data, buffers concurrent updates during +replay, replays again after reconnects or `app-data.resync` hints, and maps the +raw contract payload to `{ path, value, deleted }` with `value: undefined` for +deletes. Use raw `bb.on({ event: "app-data:changed", applicationId?, prefix? })` +when the callback needs contract fields such as `applicationId` or `version`. +Use `realtime:connection` with `event.reconnected === true` to trigger any extra +refetch or reconciliation your app needs after the SDK has reconnected. + +Payload types come from `ChangedMessage` in `@bb/domain` and +`AppDataBroadcastMessage` in `@bb/server-contract`; do not invent payload +fields in app code. + +Message the thread context that opened the app with: + +```ts +await window.bb.message.send({ + payload: { + kind: "review-board.status", + open: 3 + } +}); +``` + +`targetThreadId` is optional in the browser call: + +```ts +await window.bb.message.send({ payload: "Please review this.", targetThreadId }); +``` + +When the app was opened by a thread, the injected app session supplies the +target. Non-iframe callers must provide a target thread or the server returns +`message_target_required`. + +The injected runtime currently exposes the broader bb SDK prototype too: +`window.bb.threads`, `window.bb.apps`, `window.bb.hosts`, +`window.bb.projects`, `window.bb.environments`, `window.bb.providers`, +`window.bb.managers`, `window.bb.replay`, and `window.bb.status`. Treat those +as CLI-level power inside the browser prototype; prefer the current-app +`data` and `message` areas for ordinary app behavior. + +## App Data + +App data paths are relative to `/apps//data/`. + +Rules: + +- Path must not be empty. +- No leading or trailing slash. +- No backslashes or NUL bytes. +- No `.` or `..` segments. +- No dot-prefixed segments. +- Up to 8 path segments. +- Whole path length up to 512 characters. +- Each segment is 1 to 80 characters and uses letters, numbers, dots, + underscores, and hyphens. + +Data values are JSON. The server writes canonical pretty JSON files under +`data/`. A common app pattern is one JSON file per record, for example: + +```text +todos/ +``` + +The generated Todo scaffold binds to `todos/` and uses records like: + +```json +{ + "id": "todo_20260603_review_notes", + "title": "Review notes from the manager", + "done": false, + "createdAt": "2026-06-03T20:00:00.000Z", + "updatedAt": "2026-06-03T20:00:00.000Z" +} +``` + +Prefer per-record paths for reactive lists. Avoid storing the whole UI in one +large `state.json` unless a single-document model is genuinely better. + +## bb CLI + +App management: + +```bash +bb app list +bb app list --json +bb app new --name "Review Board" +bb app new --slug review-board +bb app show review-board +bb app show review-board --json +bb app current --json +bb app delete review-board --yes +``` + +Data management from outside the app: + +```bash +bb app data list review-board +bb app data list review-board todos +bb app data read review-board todos/todo_20260603_review_notes +printf '%s\n' '{"ok":true}' | bb app data write review-board state.json --stdin +bb app data write review-board state.json --file ./state.json +bb app data delete review-board state.json +``` + +`bb app data list [path]` treats `[path]` as a prefix. `read` +prints the stored JSON value. `write` requires `--file ` or +`--stdin`. Commands accept application ids, not display names. + +There is also a message command for non-browser sends: + +```bash +bb app message review-board --target-thread thr_123 --json '"Please review this."' +``` + +## Skills Injection + +Three sources are discovered for injected skills: + +```text + +/skills//SKILL.md +/apps//skills//SKILL.md +``` + +Built-in skills (including this one) ship with bb itself from +`apps/server/src/services/skills/builtin-skills//SKILL.md` and are +injected on every install without any data-dir setup. For the normal +production data dir, `/skills` is `~/.bb/skills`; skills there are +user-authored data-dir global skills. + +Each injected skill must have agentskills-style YAML frontmatter: + +```yaml +--- +name: add-todos +description: Add todos to this bb Todo app by writing per-item app data records. +--- +``` + +The frontmatter `name` must match the directory name. Descriptions must be +non-empty. Symlinked roots or skill files are skipped. A data-dir or app-local +skill that reuses a built-in skill's name overrides the built-in copy. If two +injected skills share the same name across the data-dir root and any app root, +all colliding skills with that name are skipped. Keep app-local skill names +unique. + +App-local skills are discovered only for valid global apps whose +`manifest.json` parses and whose `manifest.id` matches the app directory. The +server passes discovered sources to the host daemon, which stages them into +provider-specific skill roots for agents. + +Use app-local skills to teach agents how to drive that specific app's data +model. The generated Todo app's `skills/add-todos/SKILL.md` is the pattern: +state the record path, JSON shape, required fields, and CLI write command. + +## End-To-End Pattern + +Create: + +```bash +bb app new --slug review-board --name "Review Board" +bb app show review-board --json +``` + +Edit and rebuild: + +```bash +app_root="$(bb app show review-board --json | jq -r .appRootPath)" +cd "$app_root/source" +pnpm install +# edit source/src/App.tsx, source/src/useTodos.ts, etc. +pnpm build +``` + +See it through the running bb server or bb UI: + +```text +/api/v1/apps/review-board/ +``` + +Write data in the browser: + +```ts +const todo = { + id: "todo_20260603_review_notes", + title: "Review notes from the manager", + done: false, + createdAt: new Date().toISOString(), + updatedAt: new Date().toISOString() +}; + +await window.bb.data.write({ + path: `todos/${todo.id}`, + value: todo +}); + +const unsubscribe = window.bb.data.onChange({ + prefix: "todos", + callback(event) { + console.log(event.path, event.deleted, event.value); + } +}); +``` + +Write the same kind of data from an agent or shell: + +```bash +todo_id="todo_20260603_review_notes" +created_at="$(date -u +%Y-%m-%dT%H:%M:%S.000Z)" +printf '%s\n' "{\"id\":\"$todo_id\",\"title\":\"Review notes from the manager\",\"done\":false,\"createdAt\":\"$created_at\",\"updatedAt\":\"$created_at\"}" | + bb app data write review-board "todos/$todo_id" --stdin + +bb app data list review-board todos +bb app data read review-board "todos/$todo_id" +``` + +Notify the owning thread from the app: + +```ts +await window.bb.message.send({ + payload: { + kind: "review-board.updated", + changedPath: `todos/${todo.id}` + } +}); +``` diff --git a/apps/server/src/services/skills/injected-skills.ts b/apps/server/src/services/skills/injected-skills.ts index db0739ab6..3abaefabb 100644 --- a/apps/server/src/services/skills/injected-skills.ts +++ b/apps/server/src/services/skills/injected-skills.ts @@ -38,6 +38,7 @@ const skillFrontmatterSchema = z .passthrough(); export interface ResolveInjectedSkillSourcesArgs { + builtinSkillsRootPath: string; dataDir: string; } @@ -206,6 +207,17 @@ function readSkillCandidate( return null; } + if (args.sourceType === "builtin") { + return { + sourceType: "builtin", + applicationId: null, + name: frontmatter.data.name, + description: frontmatter.data.description, + sourceRootPath: args.candidatePath, + skillFilePath, + }; + } + if (args.sourceType === "data-dir") { return { sourceType: "data-dir", @@ -401,6 +413,38 @@ function readValidApplicationIds( return applicationIds; } +interface ExcludeOverriddenBuiltinsArgs { + builtinSources: readonly HostDaemonInjectedSkillSource[]; + userSources: readonly HostDaemonInjectedSkillSource[]; +} + +/** + * A data-dir or global-app skill that reuses a built-in skill's name + * overrides the built-in copy, even when the user sources later collide + * each other out: a user touching a name always silences the built-in. + */ +function excludeOverriddenBuiltins( + logger: ServerLogger, + args: ExcludeOverriddenBuiltinsArgs, +): HostDaemonInjectedSkillSource[] { + const userClaimedNames = new Set( + args.userSources.map((source) => source.name), + ); + return args.builtinSources.filter((source) => { + if (!userClaimedNames.has(source.name)) { + return true; + } + logger.info( + { + name: source.name, + sourceRootPath: source.sourceRootPath, + }, + "Built-in injected skill overridden by user skill", + ); + return false; + }); +} + function excludeCollisions( logger: ServerLogger, sources: readonly HostDaemonInjectedSkillSource[], @@ -431,10 +475,29 @@ function excludeCollisions( return resolved.sort((left, right) => left.name.localeCompare(right.name)); } +/** + * Discovers the injected skills for a thread command from three roots: + * built-in skills bundled with the server, data-dir skills under + * `/skills`, and app-local skills under each valid global app. + * User (data-dir/global-app) skills override same-named built-ins; name + * collisions among user sources drop all colliding user sources. + * + * All source paths are server-machine paths that the host daemon reads from + * its local filesystem. On additional hosts on other machines the paths do + * not resolve and the daemon skips the skill with a staging warning — a + * pre-existing limitation shared with data-dir and app skills. + */ export function resolveInjectedSkillSources( logger: ServerLogger, args: ResolveInjectedSkillSourcesArgs, ): HostDaemonInjectedSkillSource[] { + const builtinSources = readSkillsRoot({ + applicationId: null, + logger, + skillsRootPath: args.builtinSkillsRootPath, + sourceType: "builtin", + }); + const dataDirSources = readSkillsRoot({ applicationId: null, logger, @@ -463,5 +526,11 @@ export function resolveInjectedSkillSources( ); } - return excludeCollisions(logger, [...dataDirSources, ...appSources]); + const userSources = [...dataDirSources, ...appSources]; + const activeBuiltinSources = excludeOverriddenBuiltins(logger, { + builtinSources, + userSources, + }); + + return excludeCollisions(logger, [...activeBuiltinSources, ...userSources]); } diff --git a/apps/server/src/services/threads/thread-runtime-config.ts b/apps/server/src/services/threads/thread-runtime-config.ts index 7ef6480b7..4b44d05d2 100644 --- a/apps/server/src/services/threads/thread-runtime-config.ts +++ b/apps/server/src/services/threads/thread-runtime-config.ts @@ -156,6 +156,7 @@ export async function resolveThreadRuntimeCommandConfig( defaultSource?.type === "local_path" ? defaultSource.path : workspacePath; const { workspaceProvisionType } = args.environment; const injectedSkillSources = resolveInjectedSkillSources(deps.logger, { + builtinSkillsRootPath: deps.config.builtinSkillsRootPath, dataDir: deps.config.dataDir, }); diff --git a/apps/server/src/start-server.ts b/apps/server/src/start-server.ts index 11da811e0..6c28587b9 100644 --- a/apps/server/src/start-server.ts +++ b/apps/server/src/start-server.ts @@ -9,6 +9,7 @@ import { initDb } from "./db.js"; import { createApp } from "./server.js"; import { PendingInteractionLifecycle } from "./services/interactions/pending-interactions.js"; import { createMachineAuthService } from "./services/machine-auth.js"; +import { resolveBuiltinSkillsRootPath } from "./services/skills/builtin-skills-copy.js"; import { createAppVersionService } from "./services/system/app-version.js"; import { createBbAppManagedConfigReloader } from "./services/system/bb-app-managed-config.js"; import { startEventLoopStallMonitor } from "./services/system/event-loop-stall-monitor.js"; @@ -50,6 +51,7 @@ export async function runServer(serverConfig: ServerConfig): Promise { isProduction && existsSync(appDistDir) ? appDistDir : undefined; const runtimeConfig: ServerRuntimeConfig = { appVersion: serverConfig.BB_APP_VERSION, + builtinSkillsRootPath: resolveBuiltinSkillsRootPath(), customModels: [], dataDir: serverConfig.BB_DATA_DIR, featureFlags: serverConfig.featureFlags, diff --git a/apps/server/src/types.ts b/apps/server/src/types.ts index ca5cae134..f7e862567 100644 --- a/apps/server/src/types.ts +++ b/apps/server/src/types.ts @@ -14,6 +14,7 @@ export type ServerLogger = Pick; export interface ServerRuntimeConfig { appVersion: string; + builtinSkillsRootPath: string; customModels: CustomProviderModel[]; dataDir: string; featureFlags: FeatureFlags; diff --git a/apps/server/test/helpers/test-app.ts b/apps/server/test/helpers/test-app.ts index c4613e213..2c1a9fe39 100644 --- a/apps/server/test/helpers/test-app.ts +++ b/apps/server/test/helpers/test-app.ts @@ -127,6 +127,7 @@ export async function createTestAppHarness( }; const config: ServerRuntimeConfig = { appVersion: "0.0.0-test", + builtinSkillsRootPath: join(dataDir, "builtin-skills"), customModels: [], dataDir, featureFlags: defaultFeatureFlags, diff --git a/apps/server/test/skills/builtin-skills-copy.test.ts b/apps/server/test/skills/builtin-skills-copy.test.ts new file mode 100644 index 000000000..e4833721f --- /dev/null +++ b/apps/server/test/skills/builtin-skills-copy.test.ts @@ -0,0 +1,62 @@ +import { mkdtemp, readFile, rm } from "node:fs/promises"; +import { tmpdir } from "node:os"; +import path from "node:path"; +import { afterEach, describe, expect, it } from "vitest"; +import { + BUILTIN_SKILLS_DIRECTORY_NAME, + copyBuiltinSkills, + resolveBuiltinSkillsRootPath, + resolveBuiltinSkillsRootPathForModuleDir, +} from "../../src/services/skills/builtin-skills-copy.js"; + +const tempDirs: string[] = []; + +async function makeTempDir(): Promise { + const dir = await mkdtemp(path.join(tmpdir(), "bb-builtin-skills-copy-")); + tempDirs.push(dir); + return dir; +} + +afterEach(async () => { + await Promise.all( + tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })), + ); +}); + +describe("builtin skills copy", () => { + it("copies the bundled skills so the dist layout resolves beside the module", async () => { + // Mirrors scripts/copy-builtin-skills.ts plus the bundled server's + // module-relative resolution: copy into /builtin-skills, then + // resolve from . + const moduleDir = await makeTempDir(); + const targetPath = path.join(moduleDir, BUILTIN_SKILLS_DIRECTORY_NAME); + + await copyBuiltinSkills({ + skillsRootPath: resolveBuiltinSkillsRootPath(), + targetPath, + }); + + expect(resolveBuiltinSkillsRootPathForModuleDir({ moduleDir })).toBe( + targetPath, + ); + const sourceSkill = await readFile( + path.join( + resolveBuiltinSkillsRootPath(), + "building-bb-apps", + "SKILL.md", + ), + "utf8", + ); + await expect( + readFile(path.join(targetPath, "building-bb-apps", "SKILL.md"), "utf8"), + ).resolves.toBe(sourceSkill); + }); + + it("throws when the sentinel skill is missing beside the module", async () => { + const moduleDir = await makeTempDir(); + + expect(() => + resolveBuiltinSkillsRootPathForModuleDir({ moduleDir }), + ).toThrow("Missing built-in skills at"); + }); +}); diff --git a/apps/server/test/skills/injected-skills.test.ts b/apps/server/test/skills/injected-skills.test.ts index 7780f8506..e32252ccc 100644 --- a/apps/server/test/skills/injected-skills.test.ts +++ b/apps/server/test/skills/injected-skills.test.ts @@ -4,17 +4,19 @@ import path from "node:path"; import { afterEach, describe, expect, it } from "vitest"; import { resolveApplicationPath } from "@bb/config/app-storage-paths"; import { applicationIdSchema, type ApplicationId } from "@bb/domain"; +import { resolveBuiltinSkillsRootPath } from "../../src/services/skills/builtin-skills-copy.js"; import { resolveInjectedSkillSources } from "../../src/services/skills/injected-skills.js"; import type { ServerLogger } from "../../src/types.js"; -interface CapturedWarning { +interface CapturedLog { context: object; message: string; } interface CapturingLogger { + infos: CapturedLog[]; logger: ServerLogger; - warnings: CapturedWarning[]; + warnings: CapturedLog[]; } interface WriteSkillArgs { @@ -43,28 +45,32 @@ afterEach(async () => { }); function createCapturingLogger(): CapturingLogger { - const warnings: CapturedWarning[] = []; - function captureWarning(...args: Parameters): void { - const firstArg = args[0]; - const secondArg = args[1]; - warnings.push({ - context: - typeof firstArg === "object" && firstArg !== null ? firstArg : {}, - message: - typeof secondArg === "string" - ? secondArg - : typeof firstArg === "string" - ? firstArg - : "", - }); + const infos: CapturedLog[] = []; + const warnings: CapturedLog[] = []; + function captureTo(target: CapturedLog[]) { + return (...args: Parameters): void => { + const firstArg = args[0]; + const secondArg = args[1]; + target.push({ + context: + typeof firstArg === "object" && firstArg !== null ? firstArg : {}, + message: + typeof secondArg === "string" + ? secondArg + : typeof firstArg === "string" + ? firstArg + : "", + }); + }; } return { + infos, warnings, logger: { debug: () => undefined, error: () => undefined, - info: () => undefined, - warn: captureWarning, + info: captureTo(infos), + warn: captureTo(warnings), }, }; } @@ -123,7 +129,10 @@ describe("injected skill source discovery", () => { }); const { logger } = createCapturingLogger(); - const sources = await resolveInjectedSkillSources(logger, { dataDir }); + const sources = await resolveInjectedSkillSources(logger, { + builtinSkillsRootPath: path.join(dataDir, "builtin-skills"), + dataDir, + }); expect(sources).toEqual([ { @@ -162,7 +171,12 @@ describe("injected skill source discovery", () => { ); const { logger, warnings } = createCapturingLogger(); - expect(resolveInjectedSkillSources(logger, { dataDir })).toEqual([]); + expect( + resolveInjectedSkillSources(logger, { + builtinSkillsRootPath: path.join(dataDir, "builtin-skills"), + dataDir, + }), + ).toEqual([]); expect(warnings).toEqual([ expect.objectContaining({ message: "Skipping invalid injected skill", @@ -190,7 +204,12 @@ describe("injected skill source discovery", () => { ); const { logger, warnings } = createCapturingLogger(); - expect(resolveInjectedSkillSources(logger, { dataDir })).toEqual([]); + expect( + resolveInjectedSkillSources(logger, { + builtinSkillsRootPath: path.join(dataDir, "builtin-skills"), + dataDir, + }), + ).toEqual([]); expect(warnings[0]?.context).toMatchObject({ reason: "Skill directory is a symlink", sourceType: "data-dir", @@ -211,11 +230,180 @@ describe("injected skill source discovery", () => { }); const { logger, warnings } = createCapturingLogger(); - expect(resolveInjectedSkillSources(logger, { dataDir })).toEqual([]); + expect( + resolveInjectedSkillSources(logger, { + builtinSkillsRootPath: path.join(dataDir, "builtin-skills"), + dataDir, + }), + ).toEqual([]); expect( warnings.filter( (warning) => warning.message === "Skipping colliding injected skill", ), ).toHaveLength(2); }); + + it("aggregates built-in skills alongside user skills", async () => { + const dataDir = await makeTempDir(); + const builtinSkillsRootPath = path.join(dataDir, "builtin-skills"); + const builtinSkillRoot = await writeSkill({ + rootPath: builtinSkillsRootPath, + name: "building-bb-apps", + }); + const dataDirSkillRoot = await writeSkill({ + rootPath: path.join(dataDir, "skills"), + name: "release-notes", + }); + const { logger, warnings } = createCapturingLogger(); + + const sources = await resolveInjectedSkillSources(logger, { + builtinSkillsRootPath, + dataDir, + }); + + expect(sources).toEqual([ + { + sourceType: "builtin", + applicationId: null, + name: "building-bb-apps", + description: "Use building-bb-apps when tests need it.", + sourceRootPath: builtinSkillRoot, + skillFilePath: path.join(builtinSkillRoot, "SKILL.md"), + }, + { + sourceType: "data-dir", + applicationId: null, + name: "release-notes", + description: "Use release-notes when tests need it.", + sourceRootPath: dataDirSkillRoot, + skillFilePath: path.join(dataDirSkillRoot, "SKILL.md"), + }, + ]); + expect(warnings).toEqual([]); + }); + + it("lets a data-dir skill override a built-in skill with the same name", async () => { + const dataDir = await makeTempDir(); + const builtinSkillsRootPath = path.join(dataDir, "builtin-skills"); + await writeSkill({ + rootPath: builtinSkillsRootPath, + name: "building-bb-apps", + description: "Built-in copy.", + }); + const overrideSkillRoot = await writeSkill({ + rootPath: path.join(dataDir, "skills"), + name: "building-bb-apps", + description: "User override copy.", + }); + const { logger, infos, warnings } = createCapturingLogger(); + + const sources = await resolveInjectedSkillSources(logger, { + builtinSkillsRootPath, + dataDir, + }); + + expect(sources).toEqual([ + { + sourceType: "data-dir", + applicationId: null, + name: "building-bb-apps", + description: "User override copy.", + sourceRootPath: overrideSkillRoot, + skillFilePath: path.join(overrideSkillRoot, "SKILL.md"), + }, + ]); + expect(warnings).toEqual([]); + expect(infos).toEqual([ + expect.objectContaining({ + message: "Built-in injected skill overridden by user skill", + }), + ]); + }); + + it("lets a global app skill override a built-in skill with the same name", async () => { + const dataDir = await makeTempDir(); + const applicationId = applicationIdSchema.parse("skillstest"); + const appRootPath = await writeApplication({ dataDir, applicationId }); + const builtinSkillsRootPath = path.join(dataDir, "builtin-skills"); + await writeSkill({ + rootPath: builtinSkillsRootPath, + name: "building-bb-apps", + description: "Built-in copy.", + }); + const overrideSkillRoot = await writeSkill({ + rootPath: path.join(appRootPath, "skills"), + name: "building-bb-apps", + description: "App override copy.", + }); + const { logger, warnings } = createCapturingLogger(); + + const sources = await resolveInjectedSkillSources(logger, { + builtinSkillsRootPath, + dataDir, + }); + + expect(sources).toEqual([ + { + sourceType: "global-app", + applicationId, + name: "building-bb-apps", + description: "App override copy.", + sourceRootPath: overrideSkillRoot, + skillFilePath: path.join(overrideSkillRoot, "SKILL.md"), + }, + ]); + expect(warnings).toEqual([]); + }); + + it("keeps the built-in silenced when user sources collide over its name", async () => { + const dataDir = await makeTempDir(); + const applicationId = applicationIdSchema.parse("collision"); + const appRootPath = await writeApplication({ dataDir, applicationId }); + const builtinSkillsRootPath = path.join(dataDir, "builtin-skills"); + await writeSkill({ + rootPath: builtinSkillsRootPath, + name: "shared-skill", + }); + await writeSkill({ + rootPath: path.join(dataDir, "skills"), + name: "shared-skill", + }); + await writeSkill({ + rootPath: path.join(appRootPath, "skills"), + name: "shared-skill", + }); + const { logger, warnings } = createCapturingLogger(); + + expect( + resolveInjectedSkillSources(logger, { + builtinSkillsRootPath, + dataDir, + }), + ).toEqual([]); + expect( + warnings.filter( + (warning) => warning.message === "Skipping colliding injected skill", + ), + ).toHaveLength(2); + }); + + it("resolves the bundled built-in skills root with a valid building-bb-apps skill", async () => { + const dataDir = await makeTempDir(); + const builtinSkillsRootPath = resolveBuiltinSkillsRootPath(); + const { logger, warnings } = createCapturingLogger(); + + const sources = await resolveInjectedSkillSources(logger, { + builtinSkillsRootPath, + dataDir, + }); + + const builtinNames = sources.map((source) => source.name); + expect(builtinNames).toContain("building-bb-apps"); + for (const source of sources) { + expect(source.sourceType).toBe("builtin"); + expect(source.applicationId).toBeNull(); + expect(source.description.trim().length).toBeGreaterThan(0); + } + expect(warnings).toEqual([]); + }); }); diff --git a/apps/server/test/system/bb-app-managed-config.test.ts b/apps/server/test/system/bb-app-managed-config.test.ts index 5244b6bc7..e1a83f659 100644 --- a/apps/server/test/system/bb-app-managed-config.test.ts +++ b/apps/server/test/system/bb-app-managed-config.test.ts @@ -50,6 +50,7 @@ function createRuntimeConfig(): ServerRuntimeConfig { return { appUrl: "https://ambient-app.example.test", appVersion: "0.0.0-test", + builtinSkillsRootPath: "/tmp/bb-test/builtin-skills", customModels: [], dataDir: "/tmp/bb-test", featureFlags: defaultFeatureFlags, diff --git a/apps/server/test/threads/thread-runtime-config.test.ts b/apps/server/test/threads/thread-runtime-config.test.ts index 250e708fe..fc709521a 100644 --- a/apps/server/test/threads/thread-runtime-config.test.ts +++ b/apps/server/test/threads/thread-runtime-config.test.ts @@ -22,12 +22,12 @@ function resolveLocalTimezone(): string { } interface WriteRuntimeSkillArgs { - dataDir: string; name: string; + rootPath: string; } async function writeRuntimeSkill(args: WriteRuntimeSkillArgs): Promise { - const sourceRootPath = path.join(args.dataDir, "skills", args.name); + const sourceRootPath = path.join(args.rootPath, args.name); await mkdir(sourceRootPath, { recursive: true }); await writeFile( path.join(sourceRootPath, "SKILL.md"), @@ -294,8 +294,12 @@ describe("thread runtime config", () => { it("serializes injected skill sources into new thread start commands", async () => { await withTestHarness(async (harness) => { const sourceRootPath = await writeRuntimeSkill({ - dataDir: harness.config.dataDir, name: "release-notes", + rootPath: path.join(harness.config.dataDir, "skills"), + }); + const builtinSourceRootPath = await writeRuntimeSkill({ + name: "building-bb-apps", + rootPath: harness.config.builtinSkillsRootPath, }); const { host } = seedHostSession(harness.deps, { id: "host-runtime-injected-skills", @@ -332,6 +336,14 @@ describe("thread runtime config", () => { }); expect(command.injectedSkillSources).toEqual([ + { + sourceType: "builtin", + applicationId: null, + name: "building-bb-apps", + description: "Use building-bb-apps when server runtime tests run.", + sourceRootPath: builtinSourceRootPath, + skillFilePath: path.join(builtinSourceRootPath, "SKILL.md"), + }, { sourceType: "data-dir", applicationId: null, diff --git a/packages/host-daemon-contract/src/commands.ts b/packages/host-daemon-contract/src/commands.ts index 48a665f71..79bc5eb4a 100644 --- a/packages/host-daemon-contract/src/commands.ts +++ b/packages/host-daemon-contract/src/commands.ts @@ -28,7 +28,7 @@ import { } from "@bb/replay-capture/schema"; import { z } from "zod"; -export const HOST_DAEMON_PROTOCOL_VERSION = 31 as const; +export const HOST_DAEMON_PROTOCOL_VERSION = 32 as const; export { BRANCH_LIST_LIMIT_MAX, @@ -122,6 +122,12 @@ const hostDaemonInjectedSkillSourceBaseSchema = z export const hostDaemonInjectedSkillSourceSchema = z.discriminatedUnion( "sourceType", [ + hostDaemonInjectedSkillSourceBaseSchema + .extend({ + sourceType: z.literal("builtin"), + applicationId: z.null(), + }) + .strict(), hostDaemonInjectedSkillSourceBaseSchema .extend({ sourceType: z.literal("data-dir"), diff --git a/packages/host-daemon-contract/test/contract.test.ts b/packages/host-daemon-contract/test/contract.test.ts index b59d833f2..44d6009b2 100644 --- a/packages/host-daemon-contract/test/contract.test.ts +++ b/packages/host-daemon-contract/test/contract.test.ts @@ -22,6 +22,7 @@ import { hostDaemonEventBatchResponseSchema, hostDaemonInteractiveInterruptRequestSchema, hostDaemonInteractiveInterruptResponseSchema, + hostDaemonInjectedSkillSourceSchema, hostDaemonInteractiveRequestResponseSchema, hostDaemonInteractiveRequestSchema, hostDaemonOnlineRpcCommandSchema, @@ -1190,6 +1191,59 @@ describe("host-daemon command schemas", () => { }); }); + it("parses every injected skill source variant and pins applicationId rules", () => { + const base = { + name: "building-bb-apps", + description: "Use when building bb apps.", + sourceRootPath: "/srv/builtin-skills/building-bb-apps", + skillFilePath: "/srv/builtin-skills/building-bb-apps/SKILL.md", + }; + + expect( + hostDaemonInjectedSkillSourceSchema.parse({ + ...base, + sourceType: "builtin", + applicationId: null, + }), + ).toMatchObject({ sourceType: "builtin", applicationId: null }); + expect( + hostDaemonInjectedSkillSourceSchema.parse({ + ...base, + sourceType: "data-dir", + applicationId: null, + }), + ).toMatchObject({ sourceType: "data-dir", applicationId: null }); + expect( + hostDaemonInjectedSkillSourceSchema.parse({ + ...base, + sourceType: "global-app", + applicationId: "tasks", + }), + ).toMatchObject({ sourceType: "global-app", applicationId: "tasks" }); + + expect(() => + hostDaemonInjectedSkillSourceSchema.parse({ + ...base, + sourceType: "builtin", + applicationId: "tasks", + }), + ).toThrow(); + expect(() => + hostDaemonInjectedSkillSourceSchema.parse({ + ...base, + sourceType: "global-app", + applicationId: null, + }), + ).toThrow(); + expect(() => + hostDaemonInjectedSkillSourceSchema.parse({ + ...base, + sourceType: "bundled", + applicationId: null, + }), + ).toThrow(); + }); + it("keeps contract optional fields on an explicit allowlist", () => { const optionalFieldPaths = collectOptionalFieldPaths({ hostDaemonActiveThreadSchema: contract.hostDaemonActiveThreadSchema, diff --git a/packages/sdk/src/app-runtime-browser-bundle.generated.ts b/packages/sdk/src/app-runtime-browser-bundle.generated.ts index b0e1d673d..a243ba55d 100644 --- a/packages/sdk/src/app-runtime-browser-bundle.generated.ts +++ b/packages/sdk/src/app-runtime-browser-bundle.generated.ts @@ -1,5 +1,5 @@ // Generated by packages/sdk/scripts/generate-app-runtime-browser-bundle.mjs // Do not edit by hand. Run pnpm --filter @bb/sdk generate:app-runtime-browser-bundle to regenerate. -export const APP_RUNTIME_BROWSER_BUNDLE = "\"use strict\";\n(() => {\n var __defProp = Object.defineProperty;\n var __export = (target, all) => {\n for (var name in all)\n __defProp(target, name, { get: all[name], enumerable: true });\n };\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/external.js\n var external_exports = {};\n __export(external_exports, {\n $brand: () => $brand,\n $input: () => $input,\n $output: () => $output,\n NEVER: () => NEVER,\n TimePrecision: () => TimePrecision,\n ZodAny: () => ZodAny,\n ZodArray: () => ZodArray,\n ZodBase64: () => ZodBase64,\n ZodBase64URL: () => ZodBase64URL,\n ZodBigInt: () => ZodBigInt,\n ZodBigIntFormat: () => ZodBigIntFormat,\n ZodBoolean: () => ZodBoolean,\n ZodCIDRv4: () => ZodCIDRv4,\n ZodCIDRv6: () => ZodCIDRv6,\n ZodCUID: () => ZodCUID,\n ZodCUID2: () => ZodCUID2,\n ZodCatch: () => ZodCatch,\n ZodCodec: () => ZodCodec,\n ZodCustom: () => ZodCustom,\n ZodCustomStringFormat: () => ZodCustomStringFormat,\n ZodDate: () => ZodDate,\n ZodDefault: () => ZodDefault,\n ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,\n ZodE164: () => ZodE164,\n ZodEmail: () => ZodEmail,\n ZodEmoji: () => ZodEmoji,\n ZodEnum: () => ZodEnum,\n ZodError: () => ZodError,\n ZodExactOptional: () => ZodExactOptional,\n ZodFile: () => ZodFile,\n ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind,\n ZodFunction: () => ZodFunction,\n ZodGUID: () => ZodGUID,\n ZodIPv4: () => ZodIPv4,\n ZodIPv6: () => ZodIPv6,\n ZodISODate: () => ZodISODate,\n ZodISODateTime: () => ZodISODateTime,\n ZodISODuration: () => ZodISODuration,\n ZodISOTime: () => ZodISOTime,\n ZodIntersection: () => ZodIntersection,\n ZodIssueCode: () => ZodIssueCode,\n ZodJWT: () => ZodJWT,\n ZodKSUID: () => ZodKSUID,\n ZodLazy: () => ZodLazy,\n ZodLiteral: () => ZodLiteral,\n ZodMAC: () => ZodMAC,\n ZodMap: () => ZodMap,\n ZodNaN: () => ZodNaN,\n ZodNanoID: () => ZodNanoID,\n ZodNever: () => ZodNever,\n ZodNonOptional: () => ZodNonOptional,\n ZodNull: () => ZodNull,\n ZodNullable: () => ZodNullable,\n ZodNumber: () => ZodNumber,\n ZodNumberFormat: () => ZodNumberFormat,\n ZodObject: () => ZodObject,\n ZodOptional: () => ZodOptional,\n ZodPipe: () => ZodPipe,\n ZodPrefault: () => ZodPrefault,\n ZodPromise: () => ZodPromise,\n ZodReadonly: () => ZodReadonly,\n ZodRealError: () => ZodRealError,\n ZodRecord: () => ZodRecord,\n ZodSet: () => ZodSet,\n ZodString: () => ZodString,\n ZodStringFormat: () => ZodStringFormat,\n ZodSuccess: () => ZodSuccess,\n ZodSymbol: () => ZodSymbol,\n ZodTemplateLiteral: () => ZodTemplateLiteral,\n ZodTransform: () => ZodTransform,\n ZodTuple: () => ZodTuple,\n ZodType: () => ZodType,\n ZodULID: () => ZodULID,\n ZodURL: () => ZodURL,\n ZodUUID: () => ZodUUID,\n ZodUndefined: () => ZodUndefined,\n ZodUnion: () => ZodUnion,\n ZodUnknown: () => ZodUnknown,\n ZodVoid: () => ZodVoid,\n ZodXID: () => ZodXID,\n ZodXor: () => ZodXor,\n _ZodString: () => _ZodString,\n _default: () => _default2,\n _function: () => _function,\n any: () => any,\n array: () => array,\n base64: () => base642,\n base64url: () => base64url2,\n bigint: () => bigint2,\n boolean: () => boolean2,\n catch: () => _catch2,\n check: () => check,\n cidrv4: () => cidrv42,\n cidrv6: () => cidrv62,\n clone: () => clone,\n codec: () => codec,\n coerce: () => coerce_exports,\n config: () => config,\n core: () => core_exports2,\n cuid: () => cuid3,\n cuid2: () => cuid22,\n custom: () => custom,\n date: () => date3,\n decode: () => decode2,\n decodeAsync: () => decodeAsync2,\n describe: () => describe2,\n discriminatedUnion: () => discriminatedUnion,\n e164: () => e1642,\n email: () => email2,\n emoji: () => emoji2,\n encode: () => encode2,\n encodeAsync: () => encodeAsync2,\n endsWith: () => _endsWith,\n enum: () => _enum2,\n exactOptional: () => exactOptional,\n file: () => file,\n flattenError: () => flattenError,\n float32: () => float32,\n float64: () => float64,\n formatError: () => formatError,\n fromJSONSchema: () => fromJSONSchema,\n function: () => _function,\n getErrorMap: () => getErrorMap,\n globalRegistry: () => globalRegistry,\n gt: () => _gt,\n gte: () => _gte,\n guid: () => guid2,\n hash: () => hash,\n hex: () => hex2,\n hostname: () => hostname2,\n httpUrl: () => httpUrl,\n includes: () => _includes,\n instanceof: () => _instanceof,\n int: () => int,\n int32: () => int32,\n int64: () => int64,\n intersection: () => intersection,\n ipv4: () => ipv42,\n ipv6: () => ipv62,\n iso: () => iso_exports,\n json: () => json,\n jwt: () => jwt,\n keyof: () => keyof,\n ksuid: () => ksuid2,\n lazy: () => lazy,\n length: () => _length,\n literal: () => literal,\n locales: () => locales_exports,\n looseObject: () => looseObject,\n looseRecord: () => looseRecord,\n lowercase: () => _lowercase,\n lt: () => _lt,\n lte: () => _lte,\n mac: () => mac2,\n map: () => map,\n maxLength: () => _maxLength,\n maxSize: () => _maxSize,\n meta: () => meta2,\n mime: () => _mime,\n minLength: () => _minLength,\n minSize: () => _minSize,\n multipleOf: () => _multipleOf,\n nan: () => nan,\n nanoid: () => nanoid2,\n nativeEnum: () => nativeEnum,\n negative: () => _negative,\n never: () => never,\n nonnegative: () => _nonnegative,\n nonoptional: () => nonoptional,\n nonpositive: () => _nonpositive,\n normalize: () => _normalize,\n null: () => _null3,\n nullable: () => nullable,\n nullish: () => nullish2,\n number: () => number2,\n object: () => object,\n optional: () => optional,\n overwrite: () => _overwrite,\n parse: () => parse2,\n parseAsync: () => parseAsync2,\n partialRecord: () => partialRecord,\n pipe: () => pipe,\n positive: () => _positive,\n prefault: () => prefault,\n preprocess: () => preprocess,\n prettifyError: () => prettifyError,\n promise: () => promise,\n property: () => _property,\n readonly: () => readonly,\n record: () => record,\n refine: () => refine,\n regex: () => _regex,\n regexes: () => regexes_exports,\n registry: () => registry,\n safeDecode: () => safeDecode2,\n safeDecodeAsync: () => safeDecodeAsync2,\n safeEncode: () => safeEncode2,\n safeEncodeAsync: () => safeEncodeAsync2,\n safeParse: () => safeParse2,\n safeParseAsync: () => safeParseAsync2,\n set: () => set,\n setErrorMap: () => setErrorMap,\n size: () => _size,\n slugify: () => _slugify,\n startsWith: () => _startsWith,\n strictObject: () => strictObject,\n string: () => string2,\n stringFormat: () => stringFormat,\n stringbool: () => stringbool,\n success: () => success,\n superRefine: () => superRefine,\n symbol: () => symbol,\n templateLiteral: () => templateLiteral,\n toJSONSchema: () => toJSONSchema,\n toLowerCase: () => _toLowerCase,\n toUpperCase: () => _toUpperCase,\n transform: () => transform,\n treeifyError: () => treeifyError,\n trim: () => _trim,\n tuple: () => tuple,\n uint32: () => uint32,\n uint64: () => uint64,\n ulid: () => ulid2,\n undefined: () => _undefined3,\n union: () => union,\n unknown: () => unknown,\n uppercase: () => _uppercase,\n url: () => url,\n util: () => util_exports,\n uuid: () => uuid2,\n uuidv4: () => uuidv4,\n uuidv6: () => uuidv6,\n uuidv7: () => uuidv7,\n void: () => _void2,\n xid: () => xid2,\n xor: () => xor\n });\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/index.js\n var core_exports2 = {};\n __export(core_exports2, {\n $ZodAny: () => $ZodAny,\n $ZodArray: () => $ZodArray,\n $ZodAsyncError: () => $ZodAsyncError,\n $ZodBase64: () => $ZodBase64,\n $ZodBase64URL: () => $ZodBase64URL,\n $ZodBigInt: () => $ZodBigInt,\n $ZodBigIntFormat: () => $ZodBigIntFormat,\n $ZodBoolean: () => $ZodBoolean,\n $ZodCIDRv4: () => $ZodCIDRv4,\n $ZodCIDRv6: () => $ZodCIDRv6,\n $ZodCUID: () => $ZodCUID,\n $ZodCUID2: () => $ZodCUID2,\n $ZodCatch: () => $ZodCatch,\n $ZodCheck: () => $ZodCheck,\n $ZodCheckBigIntFormat: () => $ZodCheckBigIntFormat,\n $ZodCheckEndsWith: () => $ZodCheckEndsWith,\n $ZodCheckGreaterThan: () => $ZodCheckGreaterThan,\n $ZodCheckIncludes: () => $ZodCheckIncludes,\n $ZodCheckLengthEquals: () => $ZodCheckLengthEquals,\n $ZodCheckLessThan: () => $ZodCheckLessThan,\n $ZodCheckLowerCase: () => $ZodCheckLowerCase,\n $ZodCheckMaxLength: () => $ZodCheckMaxLength,\n $ZodCheckMaxSize: () => $ZodCheckMaxSize,\n $ZodCheckMimeType: () => $ZodCheckMimeType,\n $ZodCheckMinLength: () => $ZodCheckMinLength,\n $ZodCheckMinSize: () => $ZodCheckMinSize,\n $ZodCheckMultipleOf: () => $ZodCheckMultipleOf,\n $ZodCheckNumberFormat: () => $ZodCheckNumberFormat,\n $ZodCheckOverwrite: () => $ZodCheckOverwrite,\n $ZodCheckProperty: () => $ZodCheckProperty,\n $ZodCheckRegex: () => $ZodCheckRegex,\n $ZodCheckSizeEquals: () => $ZodCheckSizeEquals,\n $ZodCheckStartsWith: () => $ZodCheckStartsWith,\n $ZodCheckStringFormat: () => $ZodCheckStringFormat,\n $ZodCheckUpperCase: () => $ZodCheckUpperCase,\n $ZodCodec: () => $ZodCodec,\n $ZodCustom: () => $ZodCustom,\n $ZodCustomStringFormat: () => $ZodCustomStringFormat,\n $ZodDate: () => $ZodDate,\n $ZodDefault: () => $ZodDefault,\n $ZodDiscriminatedUnion: () => $ZodDiscriminatedUnion,\n $ZodE164: () => $ZodE164,\n $ZodEmail: () => $ZodEmail,\n $ZodEmoji: () => $ZodEmoji,\n $ZodEncodeError: () => $ZodEncodeError,\n $ZodEnum: () => $ZodEnum,\n $ZodError: () => $ZodError,\n $ZodExactOptional: () => $ZodExactOptional,\n $ZodFile: () => $ZodFile,\n $ZodFunction: () => $ZodFunction,\n $ZodGUID: () => $ZodGUID,\n $ZodIPv4: () => $ZodIPv4,\n $ZodIPv6: () => $ZodIPv6,\n $ZodISODate: () => $ZodISODate,\n $ZodISODateTime: () => $ZodISODateTime,\n $ZodISODuration: () => $ZodISODuration,\n $ZodISOTime: () => $ZodISOTime,\n $ZodIntersection: () => $ZodIntersection,\n $ZodJWT: () => $ZodJWT,\n $ZodKSUID: () => $ZodKSUID,\n $ZodLazy: () => $ZodLazy,\n $ZodLiteral: () => $ZodLiteral,\n $ZodMAC: () => $ZodMAC,\n $ZodMap: () => $ZodMap,\n $ZodNaN: () => $ZodNaN,\n $ZodNanoID: () => $ZodNanoID,\n $ZodNever: () => $ZodNever,\n $ZodNonOptional: () => $ZodNonOptional,\n $ZodNull: () => $ZodNull,\n $ZodNullable: () => $ZodNullable,\n $ZodNumber: () => $ZodNumber,\n $ZodNumberFormat: () => $ZodNumberFormat,\n $ZodObject: () => $ZodObject,\n $ZodObjectJIT: () => $ZodObjectJIT,\n $ZodOptional: () => $ZodOptional,\n $ZodPipe: () => $ZodPipe,\n $ZodPrefault: () => $ZodPrefault,\n $ZodPromise: () => $ZodPromise,\n $ZodReadonly: () => $ZodReadonly,\n $ZodRealError: () => $ZodRealError,\n $ZodRecord: () => $ZodRecord,\n $ZodRegistry: () => $ZodRegistry,\n $ZodSet: () => $ZodSet,\n $ZodString: () => $ZodString,\n $ZodStringFormat: () => $ZodStringFormat,\n $ZodSuccess: () => $ZodSuccess,\n $ZodSymbol: () => $ZodSymbol,\n $ZodTemplateLiteral: () => $ZodTemplateLiteral,\n $ZodTransform: () => $ZodTransform,\n $ZodTuple: () => $ZodTuple,\n $ZodType: () => $ZodType,\n $ZodULID: () => $ZodULID,\n $ZodURL: () => $ZodURL,\n $ZodUUID: () => $ZodUUID,\n $ZodUndefined: () => $ZodUndefined,\n $ZodUnion: () => $ZodUnion,\n $ZodUnknown: () => $ZodUnknown,\n $ZodVoid: () => $ZodVoid,\n $ZodXID: () => $ZodXID,\n $ZodXor: () => $ZodXor,\n $brand: () => $brand,\n $constructor: () => $constructor,\n $input: () => $input,\n $output: () => $output,\n Doc: () => Doc,\n JSONSchema: () => json_schema_exports,\n JSONSchemaGenerator: () => JSONSchemaGenerator,\n NEVER: () => NEVER,\n TimePrecision: () => TimePrecision,\n _any: () => _any,\n _array: () => _array,\n _base64: () => _base64,\n _base64url: () => _base64url,\n _bigint: () => _bigint,\n _boolean: () => _boolean,\n _catch: () => _catch,\n _check: () => _check,\n _cidrv4: () => _cidrv4,\n _cidrv6: () => _cidrv6,\n _coercedBigint: () => _coercedBigint,\n _coercedBoolean: () => _coercedBoolean,\n _coercedDate: () => _coercedDate,\n _coercedNumber: () => _coercedNumber,\n _coercedString: () => _coercedString,\n _cuid: () => _cuid,\n _cuid2: () => _cuid2,\n _custom: () => _custom,\n _date: () => _date,\n _decode: () => _decode,\n _decodeAsync: () => _decodeAsync,\n _default: () => _default,\n _discriminatedUnion: () => _discriminatedUnion,\n _e164: () => _e164,\n _email: () => _email,\n _emoji: () => _emoji2,\n _encode: () => _encode,\n _encodeAsync: () => _encodeAsync,\n _endsWith: () => _endsWith,\n _enum: () => _enum,\n _file: () => _file,\n _float32: () => _float32,\n _float64: () => _float64,\n _gt: () => _gt,\n _gte: () => _gte,\n _guid: () => _guid,\n _includes: () => _includes,\n _int: () => _int,\n _int32: () => _int32,\n _int64: () => _int64,\n _intersection: () => _intersection,\n _ipv4: () => _ipv4,\n _ipv6: () => _ipv6,\n _isoDate: () => _isoDate,\n _isoDateTime: () => _isoDateTime,\n _isoDuration: () => _isoDuration,\n _isoTime: () => _isoTime,\n _jwt: () => _jwt,\n _ksuid: () => _ksuid,\n _lazy: () => _lazy,\n _length: () => _length,\n _literal: () => _literal,\n _lowercase: () => _lowercase,\n _lt: () => _lt,\n _lte: () => _lte,\n _mac: () => _mac,\n _map: () => _map,\n _max: () => _lte,\n _maxLength: () => _maxLength,\n _maxSize: () => _maxSize,\n _mime: () => _mime,\n _min: () => _gte,\n _minLength: () => _minLength,\n _minSize: () => _minSize,\n _multipleOf: () => _multipleOf,\n _nan: () => _nan,\n _nanoid: () => _nanoid,\n _nativeEnum: () => _nativeEnum,\n _negative: () => _negative,\n _never: () => _never,\n _nonnegative: () => _nonnegative,\n _nonoptional: () => _nonoptional,\n _nonpositive: () => _nonpositive,\n _normalize: () => _normalize,\n _null: () => _null2,\n _nullable: () => _nullable,\n _number: () => _number,\n _optional: () => _optional,\n _overwrite: () => _overwrite,\n _parse: () => _parse,\n _parseAsync: () => _parseAsync,\n _pipe: () => _pipe,\n _positive: () => _positive,\n _promise: () => _promise,\n _property: () => _property,\n _readonly: () => _readonly,\n _record: () => _record,\n _refine: () => _refine,\n _regex: () => _regex,\n _safeDecode: () => _safeDecode,\n _safeDecodeAsync: () => _safeDecodeAsync,\n _safeEncode: () => _safeEncode,\n _safeEncodeAsync: () => _safeEncodeAsync,\n _safeParse: () => _safeParse,\n _safeParseAsync: () => _safeParseAsync,\n _set: () => _set,\n _size: () => _size,\n _slugify: () => _slugify,\n _startsWith: () => _startsWith,\n _string: () => _string,\n _stringFormat: () => _stringFormat,\n _stringbool: () => _stringbool,\n _success: () => _success,\n _superRefine: () => _superRefine,\n _symbol: () => _symbol,\n _templateLiteral: () => _templateLiteral,\n _toLowerCase: () => _toLowerCase,\n _toUpperCase: () => _toUpperCase,\n _transform: () => _transform,\n _trim: () => _trim,\n _tuple: () => _tuple,\n _uint32: () => _uint32,\n _uint64: () => _uint64,\n _ulid: () => _ulid,\n _undefined: () => _undefined2,\n _union: () => _union,\n _unknown: () => _unknown,\n _uppercase: () => _uppercase,\n _url: () => _url,\n _uuid: () => _uuid,\n _uuidv4: () => _uuidv4,\n _uuidv6: () => _uuidv6,\n _uuidv7: () => _uuidv7,\n _void: () => _void,\n _xid: () => _xid,\n _xor: () => _xor,\n clone: () => clone,\n config: () => config,\n createStandardJSONSchemaMethod: () => createStandardJSONSchemaMethod,\n createToJSONSchemaMethod: () => createToJSONSchemaMethod,\n decode: () => decode,\n decodeAsync: () => decodeAsync,\n describe: () => describe,\n encode: () => encode,\n encodeAsync: () => encodeAsync,\n extractDefs: () => extractDefs,\n finalize: () => finalize,\n flattenError: () => flattenError,\n formatError: () => formatError,\n globalConfig: () => globalConfig,\n globalRegistry: () => globalRegistry,\n initializeContext: () => initializeContext,\n isValidBase64: () => isValidBase64,\n isValidBase64URL: () => isValidBase64URL,\n isValidJWT: () => isValidJWT,\n locales: () => locales_exports,\n meta: () => meta,\n parse: () => parse,\n parseAsync: () => parseAsync,\n prettifyError: () => prettifyError,\n process: () => process,\n regexes: () => regexes_exports,\n registry: () => registry,\n safeDecode: () => safeDecode,\n safeDecodeAsync: () => safeDecodeAsync,\n safeEncode: () => safeEncode,\n safeEncodeAsync: () => safeEncodeAsync,\n safeParse: () => safeParse,\n safeParseAsync: () => safeParseAsync,\n toDotPath: () => toDotPath,\n toJSONSchema: () => toJSONSchema,\n treeifyError: () => treeifyError,\n util: () => util_exports,\n version: () => version\n });\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/core.js\n var NEVER = Object.freeze({\n status: \"aborted\"\n });\n // @__NO_SIDE_EFFECTS__\n function $constructor(name, initializer3, params) {\n function init(inst, def) {\n if (!inst._zod) {\n Object.defineProperty(inst, \"_zod\", {\n value: {\n def,\n constr: _,\n traits: /* @__PURE__ */ new Set()\n },\n enumerable: false\n });\n }\n if (inst._zod.traits.has(name)) {\n return;\n }\n inst._zod.traits.add(name);\n initializer3(inst, def);\n const proto = _.prototype;\n const keys = Object.keys(proto);\n for (let i = 0; i < keys.length; i++) {\n const k = keys[i];\n if (!(k in inst)) {\n inst[k] = proto[k].bind(inst);\n }\n }\n }\n const Parent = params?.Parent ?? Object;\n class Definition extends Parent {\n }\n Object.defineProperty(Definition, \"name\", { value: name });\n function _(def) {\n var _a2;\n const inst = params?.Parent ? new Definition() : this;\n init(inst, def);\n (_a2 = inst._zod).deferred ?? (_a2.deferred = []);\n for (const fn of inst._zod.deferred) {\n fn();\n }\n return inst;\n }\n Object.defineProperty(_, \"init\", { value: init });\n Object.defineProperty(_, Symbol.hasInstance, {\n value: (inst) => {\n if (params?.Parent && inst instanceof params.Parent)\n return true;\n return inst?._zod?.traits?.has(name);\n }\n });\n Object.defineProperty(_, \"name\", { value: name });\n return _;\n }\n var $brand = /* @__PURE__ */ Symbol(\"zod_brand\");\n var $ZodAsyncError = class extends Error {\n constructor() {\n super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);\n }\n };\n var $ZodEncodeError = class extends Error {\n constructor(name) {\n super(`Encountered unidirectional transform during encode: ${name}`);\n this.name = \"ZodEncodeError\";\n }\n };\n var globalConfig = {};\n function config(newConfig) {\n if (newConfig)\n Object.assign(globalConfig, newConfig);\n return globalConfig;\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/util.js\n var util_exports = {};\n __export(util_exports, {\n BIGINT_FORMAT_RANGES: () => BIGINT_FORMAT_RANGES,\n Class: () => Class,\n NUMBER_FORMAT_RANGES: () => NUMBER_FORMAT_RANGES,\n aborted: () => aborted,\n allowsEval: () => allowsEval,\n assert: () => assert,\n assertEqual: () => assertEqual,\n assertIs: () => assertIs,\n assertNever: () => assertNever,\n assertNotEqual: () => assertNotEqual,\n assignProp: () => assignProp,\n base64ToUint8Array: () => base64ToUint8Array,\n base64urlToUint8Array: () => base64urlToUint8Array,\n cached: () => cached,\n captureStackTrace: () => captureStackTrace,\n cleanEnum: () => cleanEnum,\n cleanRegex: () => cleanRegex,\n clone: () => clone,\n cloneDef: () => cloneDef,\n createTransparentProxy: () => createTransparentProxy,\n defineLazy: () => defineLazy,\n esc: () => esc,\n escapeRegex: () => escapeRegex,\n extend: () => extend,\n finalizeIssue: () => finalizeIssue,\n floatSafeRemainder: () => floatSafeRemainder,\n getElementAtPath: () => getElementAtPath,\n getEnumValues: () => getEnumValues,\n getLengthableOrigin: () => getLengthableOrigin,\n getParsedType: () => getParsedType,\n getSizableOrigin: () => getSizableOrigin,\n hexToUint8Array: () => hexToUint8Array,\n isObject: () => isObject,\n isPlainObject: () => isPlainObject,\n issue: () => issue,\n joinValues: () => joinValues,\n jsonStringifyReplacer: () => jsonStringifyReplacer,\n merge: () => merge,\n mergeDefs: () => mergeDefs,\n normalizeParams: () => normalizeParams,\n nullish: () => nullish,\n numKeys: () => numKeys,\n objectClone: () => objectClone,\n omit: () => omit,\n optionalKeys: () => optionalKeys,\n parsedType: () => parsedType,\n partial: () => partial,\n pick: () => pick,\n prefixIssues: () => prefixIssues,\n primitiveTypes: () => primitiveTypes,\n promiseAllObject: () => promiseAllObject,\n propertyKeyTypes: () => propertyKeyTypes,\n randomString: () => randomString,\n required: () => required,\n safeExtend: () => safeExtend,\n shallowClone: () => shallowClone,\n slugify: () => slugify,\n stringifyPrimitive: () => stringifyPrimitive,\n uint8ArrayToBase64: () => uint8ArrayToBase64,\n uint8ArrayToBase64url: () => uint8ArrayToBase64url,\n uint8ArrayToHex: () => uint8ArrayToHex,\n unwrapMessage: () => unwrapMessage\n });\n function assertEqual(val) {\n return val;\n }\n function assertNotEqual(val) {\n return val;\n }\n function assertIs(_arg) {\n }\n function assertNever(_x) {\n throw new Error(\"Unexpected value in exhaustive check\");\n }\n function assert(_) {\n }\n function getEnumValues(entries) {\n const numericValues = Object.values(entries).filter((v) => typeof v === \"number\");\n const values = Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v);\n return values;\n }\n function joinValues(array2, separator = \"|\") {\n return array2.map((val) => stringifyPrimitive(val)).join(separator);\n }\n function jsonStringifyReplacer(_, value) {\n if (typeof value === \"bigint\")\n return value.toString();\n return value;\n }\n function cached(getter) {\n const set2 = false;\n return {\n get value() {\n if (!set2) {\n const value = getter();\n Object.defineProperty(this, \"value\", { value });\n return value;\n }\n throw new Error(\"cached value already set\");\n }\n };\n }\n function nullish(input) {\n return input === null || input === void 0;\n }\n function cleanRegex(source) {\n const start = source.startsWith(\"^\") ? 1 : 0;\n const end = source.endsWith(\"$\") ? source.length - 1 : source.length;\n return source.slice(start, end);\n }\n function floatSafeRemainder(val, step) {\n const valDecCount = (val.toString().split(\".\")[1] || \"\").length;\n const stepString = step.toString();\n let stepDecCount = (stepString.split(\".\")[1] || \"\").length;\n if (stepDecCount === 0 && /\\d?e-\\d?/.test(stepString)) {\n const match = stepString.match(/\\d?e-(\\d?)/);\n if (match?.[1]) {\n stepDecCount = Number.parseInt(match[1]);\n }\n }\n const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;\n const valInt = Number.parseInt(val.toFixed(decCount).replace(\".\", \"\"));\n const stepInt = Number.parseInt(step.toFixed(decCount).replace(\".\", \"\"));\n return valInt % stepInt / 10 ** decCount;\n }\n var EVALUATING = /* @__PURE__ */ Symbol(\"evaluating\");\n function defineLazy(object2, key, getter) {\n let value = void 0;\n Object.defineProperty(object2, key, {\n get() {\n if (value === EVALUATING) {\n return void 0;\n }\n if (value === void 0) {\n value = EVALUATING;\n value = getter();\n }\n return value;\n },\n set(v) {\n Object.defineProperty(object2, key, {\n value: v\n // configurable: true,\n });\n },\n configurable: true\n });\n }\n function objectClone(obj) {\n return Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj));\n }\n function assignProp(target, prop, value) {\n Object.defineProperty(target, prop, {\n value,\n writable: true,\n enumerable: true,\n configurable: true\n });\n }\n function mergeDefs(...defs) {\n const mergedDescriptors = {};\n for (const def of defs) {\n const descriptors = Object.getOwnPropertyDescriptors(def);\n Object.assign(mergedDescriptors, descriptors);\n }\n return Object.defineProperties({}, mergedDescriptors);\n }\n function cloneDef(schema) {\n return mergeDefs(schema._zod.def);\n }\n function getElementAtPath(obj, path) {\n if (!path)\n return obj;\n return path.reduce((acc, key) => acc?.[key], obj);\n }\n function promiseAllObject(promisesObj) {\n const keys = Object.keys(promisesObj);\n const promises = keys.map((key) => promisesObj[key]);\n return Promise.all(promises).then((results) => {\n const resolvedObj = {};\n for (let i = 0; i < keys.length; i++) {\n resolvedObj[keys[i]] = results[i];\n }\n return resolvedObj;\n });\n }\n function randomString(length = 10) {\n const chars = \"abcdefghijklmnopqrstuvwxyz\";\n let str = \"\";\n for (let i = 0; i < length; i++) {\n str += chars[Math.floor(Math.random() * chars.length)];\n }\n return str;\n }\n function esc(str) {\n return JSON.stringify(str);\n }\n function slugify(input) {\n return input.toLowerCase().trim().replace(/[^\\w\\s-]/g, \"\").replace(/[\\s_-]+/g, \"-\").replace(/^-+|-+$/g, \"\");\n }\n var captureStackTrace = \"captureStackTrace\" in Error ? Error.captureStackTrace : (..._args) => {\n };\n function isObject(data) {\n return typeof data === \"object\" && data !== null && !Array.isArray(data);\n }\n var allowsEval = cached(() => {\n if (typeof navigator !== \"undefined\" && navigator?.userAgent?.includes(\"Cloudflare\")) {\n return false;\n }\n try {\n const F = Function;\n new F(\"\");\n return true;\n } catch (_) {\n return false;\n }\n });\n function isPlainObject(o) {\n if (isObject(o) === false)\n return false;\n const ctor = o.constructor;\n if (ctor === void 0)\n return true;\n if (typeof ctor !== \"function\")\n return true;\n const prot = ctor.prototype;\n if (isObject(prot) === false)\n return false;\n if (Object.prototype.hasOwnProperty.call(prot, \"isPrototypeOf\") === false) {\n return false;\n }\n return true;\n }\n function shallowClone(o) {\n if (isPlainObject(o))\n return { ...o };\n if (Array.isArray(o))\n return [...o];\n return o;\n }\n function numKeys(data) {\n let keyCount = 0;\n for (const key in data) {\n if (Object.prototype.hasOwnProperty.call(data, key)) {\n keyCount++;\n }\n }\n return keyCount;\n }\n var getParsedType = (data) => {\n const t = typeof data;\n switch (t) {\n case \"undefined\":\n return \"undefined\";\n case \"string\":\n return \"string\";\n case \"number\":\n return Number.isNaN(data) ? \"nan\" : \"number\";\n case \"boolean\":\n return \"boolean\";\n case \"function\":\n return \"function\";\n case \"bigint\":\n return \"bigint\";\n case \"symbol\":\n return \"symbol\";\n case \"object\":\n if (Array.isArray(data)) {\n return \"array\";\n }\n if (data === null) {\n return \"null\";\n }\n if (data.then && typeof data.then === \"function\" && data.catch && typeof data.catch === \"function\") {\n return \"promise\";\n }\n if (typeof Map !== \"undefined\" && data instanceof Map) {\n return \"map\";\n }\n if (typeof Set !== \"undefined\" && data instanceof Set) {\n return \"set\";\n }\n if (typeof Date !== \"undefined\" && data instanceof Date) {\n return \"date\";\n }\n if (typeof File !== \"undefined\" && data instanceof File) {\n return \"file\";\n }\n return \"object\";\n default:\n throw new Error(`Unknown data type: ${t}`);\n }\n };\n var propertyKeyTypes = /* @__PURE__ */ new Set([\"string\", \"number\", \"symbol\"]);\n var primitiveTypes = /* @__PURE__ */ new Set([\"string\", \"number\", \"bigint\", \"boolean\", \"symbol\", \"undefined\"]);\n function escapeRegex(str) {\n return str.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n }\n function clone(inst, def, params) {\n const cl = new inst._zod.constr(def ?? inst._zod.def);\n if (!def || params?.parent)\n cl._zod.parent = inst;\n return cl;\n }\n function normalizeParams(_params) {\n const params = _params;\n if (!params)\n return {};\n if (typeof params === \"string\")\n return { error: () => params };\n if (params?.message !== void 0) {\n if (params?.error !== void 0)\n throw new Error(\"Cannot specify both `message` and `error` params\");\n params.error = params.message;\n }\n delete params.message;\n if (typeof params.error === \"string\")\n return { ...params, error: () => params.error };\n return params;\n }\n function createTransparentProxy(getter) {\n let target;\n return new Proxy({}, {\n get(_, prop, receiver) {\n target ?? (target = getter());\n return Reflect.get(target, prop, receiver);\n },\n set(_, prop, value, receiver) {\n target ?? (target = getter());\n return Reflect.set(target, prop, value, receiver);\n },\n has(_, prop) {\n target ?? (target = getter());\n return Reflect.has(target, prop);\n },\n deleteProperty(_, prop) {\n target ?? (target = getter());\n return Reflect.deleteProperty(target, prop);\n },\n ownKeys(_) {\n target ?? (target = getter());\n return Reflect.ownKeys(target);\n },\n getOwnPropertyDescriptor(_, prop) {\n target ?? (target = getter());\n return Reflect.getOwnPropertyDescriptor(target, prop);\n },\n defineProperty(_, prop, descriptor) {\n target ?? (target = getter());\n return Reflect.defineProperty(target, prop, descriptor);\n }\n });\n }\n function stringifyPrimitive(value) {\n if (typeof value === \"bigint\")\n return value.toString() + \"n\";\n if (typeof value === \"string\")\n return `\"${value}\"`;\n return `${value}`;\n }\n function optionalKeys(shape) {\n return Object.keys(shape).filter((k) => {\n return shape[k]._zod.optin === \"optional\" && shape[k]._zod.optout === \"optional\";\n });\n }\n var NUMBER_FORMAT_RANGES = {\n safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],\n int32: [-2147483648, 2147483647],\n uint32: [0, 4294967295],\n float32: [-34028234663852886e22, 34028234663852886e22],\n float64: [-Number.MAX_VALUE, Number.MAX_VALUE]\n };\n var BIGINT_FORMAT_RANGES = {\n int64: [/* @__PURE__ */ BigInt(\"-9223372036854775808\"), /* @__PURE__ */ BigInt(\"9223372036854775807\")],\n uint64: [/* @__PURE__ */ BigInt(0), /* @__PURE__ */ BigInt(\"18446744073709551615\")]\n };\n function pick(schema, mask) {\n const currDef = schema._zod.def;\n const checks = currDef.checks;\n const hasChecks = checks && checks.length > 0;\n if (hasChecks) {\n throw new Error(\".pick() cannot be used on object schemas containing refinements\");\n }\n const def = mergeDefs(schema._zod.def, {\n get shape() {\n const newShape = {};\n for (const key in mask) {\n if (!(key in currDef.shape)) {\n throw new Error(`Unrecognized key: \"${key}\"`);\n }\n if (!mask[key])\n continue;\n newShape[key] = currDef.shape[key];\n }\n assignProp(this, \"shape\", newShape);\n return newShape;\n },\n checks: []\n });\n return clone(schema, def);\n }\n function omit(schema, mask) {\n const currDef = schema._zod.def;\n const checks = currDef.checks;\n const hasChecks = checks && checks.length > 0;\n if (hasChecks) {\n throw new Error(\".omit() cannot be used on object schemas containing refinements\");\n }\n const def = mergeDefs(schema._zod.def, {\n get shape() {\n const newShape = { ...schema._zod.def.shape };\n for (const key in mask) {\n if (!(key in currDef.shape)) {\n throw new Error(`Unrecognized key: \"${key}\"`);\n }\n if (!mask[key])\n continue;\n delete newShape[key];\n }\n assignProp(this, \"shape\", newShape);\n return newShape;\n },\n checks: []\n });\n return clone(schema, def);\n }\n function extend(schema, shape) {\n if (!isPlainObject(shape)) {\n throw new Error(\"Invalid input to extend: expected a plain object\");\n }\n const checks = schema._zod.def.checks;\n const hasChecks = checks && checks.length > 0;\n if (hasChecks) {\n const existingShape = schema._zod.def.shape;\n for (const key in shape) {\n if (Object.getOwnPropertyDescriptor(existingShape, key) !== void 0) {\n throw new Error(\"Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.\");\n }\n }\n }\n const def = mergeDefs(schema._zod.def, {\n get shape() {\n const _shape = { ...schema._zod.def.shape, ...shape };\n assignProp(this, \"shape\", _shape);\n return _shape;\n }\n });\n return clone(schema, def);\n }\n function safeExtend(schema, shape) {\n if (!isPlainObject(shape)) {\n throw new Error(\"Invalid input to safeExtend: expected a plain object\");\n }\n const def = mergeDefs(schema._zod.def, {\n get shape() {\n const _shape = { ...schema._zod.def.shape, ...shape };\n assignProp(this, \"shape\", _shape);\n return _shape;\n }\n });\n return clone(schema, def);\n }\n function merge(a, b) {\n const def = mergeDefs(a._zod.def, {\n get shape() {\n const _shape = { ...a._zod.def.shape, ...b._zod.def.shape };\n assignProp(this, \"shape\", _shape);\n return _shape;\n },\n get catchall() {\n return b._zod.def.catchall;\n },\n checks: []\n // delete existing checks\n });\n return clone(a, def);\n }\n function partial(Class2, schema, mask) {\n const currDef = schema._zod.def;\n const checks = currDef.checks;\n const hasChecks = checks && checks.length > 0;\n if (hasChecks) {\n throw new Error(\".partial() cannot be used on object schemas containing refinements\");\n }\n const def = mergeDefs(schema._zod.def, {\n get shape() {\n const oldShape = schema._zod.def.shape;\n const shape = { ...oldShape };\n if (mask) {\n for (const key in mask) {\n if (!(key in oldShape)) {\n throw new Error(`Unrecognized key: \"${key}\"`);\n }\n if (!mask[key])\n continue;\n shape[key] = Class2 ? new Class2({\n type: \"optional\",\n innerType: oldShape[key]\n }) : oldShape[key];\n }\n } else {\n for (const key in oldShape) {\n shape[key] = Class2 ? new Class2({\n type: \"optional\",\n innerType: oldShape[key]\n }) : oldShape[key];\n }\n }\n assignProp(this, \"shape\", shape);\n return shape;\n },\n checks: []\n });\n return clone(schema, def);\n }\n function required(Class2, schema, mask) {\n const def = mergeDefs(schema._zod.def, {\n get shape() {\n const oldShape = schema._zod.def.shape;\n const shape = { ...oldShape };\n if (mask) {\n for (const key in mask) {\n if (!(key in shape)) {\n throw new Error(`Unrecognized key: \"${key}\"`);\n }\n if (!mask[key])\n continue;\n shape[key] = new Class2({\n type: \"nonoptional\",\n innerType: oldShape[key]\n });\n }\n } else {\n for (const key in oldShape) {\n shape[key] = new Class2({\n type: \"nonoptional\",\n innerType: oldShape[key]\n });\n }\n }\n assignProp(this, \"shape\", shape);\n return shape;\n }\n });\n return clone(schema, def);\n }\n function aborted(x, startIndex = 0) {\n if (x.aborted === true)\n return true;\n for (let i = startIndex; i < x.issues.length; i++) {\n if (x.issues[i]?.continue !== true) {\n return true;\n }\n }\n return false;\n }\n function prefixIssues(path, issues) {\n return issues.map((iss) => {\n var _a2;\n (_a2 = iss).path ?? (_a2.path = []);\n iss.path.unshift(path);\n return iss;\n });\n }\n function unwrapMessage(message) {\n return typeof message === \"string\" ? message : message?.message;\n }\n function finalizeIssue(iss, ctx, config2) {\n const full = { ...iss, path: iss.path ?? [] };\n if (!iss.message) {\n const message = unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config2.customError?.(iss)) ?? unwrapMessage(config2.localeError?.(iss)) ?? \"Invalid input\";\n full.message = message;\n }\n delete full.inst;\n delete full.continue;\n if (!ctx?.reportInput) {\n delete full.input;\n }\n return full;\n }\n function getSizableOrigin(input) {\n if (input instanceof Set)\n return \"set\";\n if (input instanceof Map)\n return \"map\";\n if (input instanceof File)\n return \"file\";\n return \"unknown\";\n }\n function getLengthableOrigin(input) {\n if (Array.isArray(input))\n return \"array\";\n if (typeof input === \"string\")\n return \"string\";\n return \"unknown\";\n }\n function parsedType(data) {\n const t = typeof data;\n switch (t) {\n case \"number\": {\n return Number.isNaN(data) ? \"nan\" : \"number\";\n }\n case \"object\": {\n if (data === null) {\n return \"null\";\n }\n if (Array.isArray(data)) {\n return \"array\";\n }\n const obj = data;\n if (obj && Object.getPrototypeOf(obj) !== Object.prototype && \"constructor\" in obj && obj.constructor) {\n return obj.constructor.name;\n }\n }\n }\n return t;\n }\n function issue(...args) {\n const [iss, input, inst] = args;\n if (typeof iss === \"string\") {\n return {\n message: iss,\n code: \"custom\",\n input,\n inst\n };\n }\n return { ...iss };\n }\n function cleanEnum(obj) {\n return Object.entries(obj).filter(([k, _]) => {\n return Number.isNaN(Number.parseInt(k, 10));\n }).map((el) => el[1]);\n }\n function base64ToUint8Array(base643) {\n const binaryString = atob(base643);\n const bytes = new Uint8Array(binaryString.length);\n for (let i = 0; i < binaryString.length; i++) {\n bytes[i] = binaryString.charCodeAt(i);\n }\n return bytes;\n }\n function uint8ArrayToBase64(bytes) {\n let binaryString = \"\";\n for (let i = 0; i < bytes.length; i++) {\n binaryString += String.fromCharCode(bytes[i]);\n }\n return btoa(binaryString);\n }\n function base64urlToUint8Array(base64url3) {\n const base643 = base64url3.replace(/-/g, \"+\").replace(/_/g, \"/\");\n const padding = \"=\".repeat((4 - base643.length % 4) % 4);\n return base64ToUint8Array(base643 + padding);\n }\n function uint8ArrayToBase64url(bytes) {\n return uint8ArrayToBase64(bytes).replace(/\\+/g, \"-\").replace(/\\//g, \"_\").replace(/=/g, \"\");\n }\n function hexToUint8Array(hex3) {\n const cleanHex = hex3.replace(/^0x/, \"\");\n if (cleanHex.length % 2 !== 0) {\n throw new Error(\"Invalid hex string length\");\n }\n const bytes = new Uint8Array(cleanHex.length / 2);\n for (let i = 0; i < cleanHex.length; i += 2) {\n bytes[i / 2] = Number.parseInt(cleanHex.slice(i, i + 2), 16);\n }\n return bytes;\n }\n function uint8ArrayToHex(bytes) {\n return Array.from(bytes).map((b) => b.toString(16).padStart(2, \"0\")).join(\"\");\n }\n var Class = class {\n constructor(..._args) {\n }\n };\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/errors.js\n var initializer = (inst, def) => {\n inst.name = \"$ZodError\";\n Object.defineProperty(inst, \"_zod\", {\n value: inst._zod,\n enumerable: false\n });\n Object.defineProperty(inst, \"issues\", {\n value: def,\n enumerable: false\n });\n inst.message = JSON.stringify(def, jsonStringifyReplacer, 2);\n Object.defineProperty(inst, \"toString\", {\n value: () => inst.message,\n enumerable: false\n });\n };\n var $ZodError = $constructor(\"$ZodError\", initializer);\n var $ZodRealError = $constructor(\"$ZodError\", initializer, { Parent: Error });\n function flattenError(error48, mapper = (issue2) => issue2.message) {\n const fieldErrors = {};\n const formErrors = [];\n for (const sub of error48.issues) {\n if (sub.path.length > 0) {\n fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];\n fieldErrors[sub.path[0]].push(mapper(sub));\n } else {\n formErrors.push(mapper(sub));\n }\n }\n return { formErrors, fieldErrors };\n }\n function formatError(error48, mapper = (issue2) => issue2.message) {\n const fieldErrors = { _errors: [] };\n const processError = (error49) => {\n for (const issue2 of error49.issues) {\n if (issue2.code === \"invalid_union\" && issue2.errors.length) {\n issue2.errors.map((issues) => processError({ issues }));\n } else if (issue2.code === \"invalid_key\") {\n processError({ issues: issue2.issues });\n } else if (issue2.code === \"invalid_element\") {\n processError({ issues: issue2.issues });\n } else if (issue2.path.length === 0) {\n fieldErrors._errors.push(mapper(issue2));\n } else {\n let curr = fieldErrors;\n let i = 0;\n while (i < issue2.path.length) {\n const el = issue2.path[i];\n const terminal = i === issue2.path.length - 1;\n if (!terminal) {\n curr[el] = curr[el] || { _errors: [] };\n } else {\n curr[el] = curr[el] || { _errors: [] };\n curr[el]._errors.push(mapper(issue2));\n }\n curr = curr[el];\n i++;\n }\n }\n }\n };\n processError(error48);\n return fieldErrors;\n }\n function treeifyError(error48, mapper = (issue2) => issue2.message) {\n const result = { errors: [] };\n const processError = (error49, path = []) => {\n var _a2, _b;\n for (const issue2 of error49.issues) {\n if (issue2.code === \"invalid_union\" && issue2.errors.length) {\n issue2.errors.map((issues) => processError({ issues }, issue2.path));\n } else if (issue2.code === \"invalid_key\") {\n processError({ issues: issue2.issues }, issue2.path);\n } else if (issue2.code === \"invalid_element\") {\n processError({ issues: issue2.issues }, issue2.path);\n } else {\n const fullpath = [...path, ...issue2.path];\n if (fullpath.length === 0) {\n result.errors.push(mapper(issue2));\n continue;\n }\n let curr = result;\n let i = 0;\n while (i < fullpath.length) {\n const el = fullpath[i];\n const terminal = i === fullpath.length - 1;\n if (typeof el === \"string\") {\n curr.properties ?? (curr.properties = {});\n (_a2 = curr.properties)[el] ?? (_a2[el] = { errors: [] });\n curr = curr.properties[el];\n } else {\n curr.items ?? (curr.items = []);\n (_b = curr.items)[el] ?? (_b[el] = { errors: [] });\n curr = curr.items[el];\n }\n if (terminal) {\n curr.errors.push(mapper(issue2));\n }\n i++;\n }\n }\n }\n };\n processError(error48);\n return result;\n }\n function toDotPath(_path) {\n const segs = [];\n const path = _path.map((seg) => typeof seg === \"object\" ? seg.key : seg);\n for (const seg of path) {\n if (typeof seg === \"number\")\n segs.push(`[${seg}]`);\n else if (typeof seg === \"symbol\")\n segs.push(`[${JSON.stringify(String(seg))}]`);\n else if (/[^\\w$]/.test(seg))\n segs.push(`[${JSON.stringify(seg)}]`);\n else {\n if (segs.length)\n segs.push(\".\");\n segs.push(seg);\n }\n }\n return segs.join(\"\");\n }\n function prettifyError(error48) {\n const lines = [];\n const issues = [...error48.issues].sort((a, b) => (a.path ?? []).length - (b.path ?? []).length);\n for (const issue2 of issues) {\n lines.push(`\\u2716 ${issue2.message}`);\n if (issue2.path?.length)\n lines.push(` \\u2192 at ${toDotPath(issue2.path)}`);\n }\n return lines.join(\"\\n\");\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/parse.js\n var _parse = (_Err) => (schema, value, _ctx, _params) => {\n const ctx = _ctx ? Object.assign(_ctx, { async: false }) : { async: false };\n const result = schema._zod.run({ value, issues: [] }, ctx);\n if (result instanceof Promise) {\n throw new $ZodAsyncError();\n }\n if (result.issues.length) {\n const e = new (_params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));\n captureStackTrace(e, _params?.callee);\n throw e;\n }\n return result.value;\n };\n var parse = /* @__PURE__ */ _parse($ZodRealError);\n var _parseAsync = (_Err) => async (schema, value, _ctx, params) => {\n const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };\n let result = schema._zod.run({ value, issues: [] }, ctx);\n if (result instanceof Promise)\n result = await result;\n if (result.issues.length) {\n const e = new (params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));\n captureStackTrace(e, params?.callee);\n throw e;\n }\n return result.value;\n };\n var parseAsync = /* @__PURE__ */ _parseAsync($ZodRealError);\n var _safeParse = (_Err) => (schema, value, _ctx) => {\n const ctx = _ctx ? { ..._ctx, async: false } : { async: false };\n const result = schema._zod.run({ value, issues: [] }, ctx);\n if (result instanceof Promise) {\n throw new $ZodAsyncError();\n }\n return result.issues.length ? {\n success: false,\n error: new (_Err ?? $ZodError)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))\n } : { success: true, data: result.value };\n };\n var safeParse = /* @__PURE__ */ _safeParse($ZodRealError);\n var _safeParseAsync = (_Err) => async (schema, value, _ctx) => {\n const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };\n let result = schema._zod.run({ value, issues: [] }, ctx);\n if (result instanceof Promise)\n result = await result;\n return result.issues.length ? {\n success: false,\n error: new _Err(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))\n } : { success: true, data: result.value };\n };\n var safeParseAsync = /* @__PURE__ */ _safeParseAsync($ZodRealError);\n var _encode = (_Err) => (schema, value, _ctx) => {\n const ctx = _ctx ? Object.assign(_ctx, { direction: \"backward\" }) : { direction: \"backward\" };\n return _parse(_Err)(schema, value, ctx);\n };\n var encode = /* @__PURE__ */ _encode($ZodRealError);\n var _decode = (_Err) => (schema, value, _ctx) => {\n return _parse(_Err)(schema, value, _ctx);\n };\n var decode = /* @__PURE__ */ _decode($ZodRealError);\n var _encodeAsync = (_Err) => async (schema, value, _ctx) => {\n const ctx = _ctx ? Object.assign(_ctx, { direction: \"backward\" }) : { direction: \"backward\" };\n return _parseAsync(_Err)(schema, value, ctx);\n };\n var encodeAsync = /* @__PURE__ */ _encodeAsync($ZodRealError);\n var _decodeAsync = (_Err) => async (schema, value, _ctx) => {\n return _parseAsync(_Err)(schema, value, _ctx);\n };\n var decodeAsync = /* @__PURE__ */ _decodeAsync($ZodRealError);\n var _safeEncode = (_Err) => (schema, value, _ctx) => {\n const ctx = _ctx ? Object.assign(_ctx, { direction: \"backward\" }) : { direction: \"backward\" };\n return _safeParse(_Err)(schema, value, ctx);\n };\n var safeEncode = /* @__PURE__ */ _safeEncode($ZodRealError);\n var _safeDecode = (_Err) => (schema, value, _ctx) => {\n return _safeParse(_Err)(schema, value, _ctx);\n };\n var safeDecode = /* @__PURE__ */ _safeDecode($ZodRealError);\n var _safeEncodeAsync = (_Err) => async (schema, value, _ctx) => {\n const ctx = _ctx ? Object.assign(_ctx, { direction: \"backward\" }) : { direction: \"backward\" };\n return _safeParseAsync(_Err)(schema, value, ctx);\n };\n var safeEncodeAsync = /* @__PURE__ */ _safeEncodeAsync($ZodRealError);\n var _safeDecodeAsync = (_Err) => async (schema, value, _ctx) => {\n return _safeParseAsync(_Err)(schema, value, _ctx);\n };\n var safeDecodeAsync = /* @__PURE__ */ _safeDecodeAsync($ZodRealError);\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/regexes.js\n var regexes_exports = {};\n __export(regexes_exports, {\n base64: () => base64,\n base64url: () => base64url,\n bigint: () => bigint,\n boolean: () => boolean,\n browserEmail: () => browserEmail,\n cidrv4: () => cidrv4,\n cidrv6: () => cidrv6,\n cuid: () => cuid,\n cuid2: () => cuid2,\n date: () => date,\n datetime: () => datetime,\n domain: () => domain,\n duration: () => duration,\n e164: () => e164,\n email: () => email,\n emoji: () => emoji,\n extendedDuration: () => extendedDuration,\n guid: () => guid,\n hex: () => hex,\n hostname: () => hostname,\n html5Email: () => html5Email,\n idnEmail: () => idnEmail,\n integer: () => integer,\n ipv4: () => ipv4,\n ipv6: () => ipv6,\n ksuid: () => ksuid,\n lowercase: () => lowercase,\n mac: () => mac,\n md5_base64: () => md5_base64,\n md5_base64url: () => md5_base64url,\n md5_hex: () => md5_hex,\n nanoid: () => nanoid,\n null: () => _null,\n number: () => number,\n rfc5322Email: () => rfc5322Email,\n sha1_base64: () => sha1_base64,\n sha1_base64url: () => sha1_base64url,\n sha1_hex: () => sha1_hex,\n sha256_base64: () => sha256_base64,\n sha256_base64url: () => sha256_base64url,\n sha256_hex: () => sha256_hex,\n sha384_base64: () => sha384_base64,\n sha384_base64url: () => sha384_base64url,\n sha384_hex: () => sha384_hex,\n sha512_base64: () => sha512_base64,\n sha512_base64url: () => sha512_base64url,\n sha512_hex: () => sha512_hex,\n string: () => string,\n time: () => time,\n ulid: () => ulid,\n undefined: () => _undefined,\n unicodeEmail: () => unicodeEmail,\n uppercase: () => uppercase,\n uuid: () => uuid,\n uuid4: () => uuid4,\n uuid6: () => uuid6,\n uuid7: () => uuid7,\n xid: () => xid\n });\n var cuid = /^[cC][^\\s-]{8,}$/;\n var cuid2 = /^[0-9a-z]+$/;\n var ulid = /^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/;\n var xid = /^[0-9a-vA-V]{20}$/;\n var ksuid = /^[A-Za-z0-9]{27}$/;\n var nanoid = /^[a-zA-Z0-9_-]{21}$/;\n var duration = /^P(?:(\\d+W)|(?!.*W)(?=\\d|T\\d)(\\d+Y)?(\\d+M)?(\\d+D)?(T(?=\\d)(\\d+H)?(\\d+M)?(\\d+([.,]\\d+)?S)?)?)$/;\n var extendedDuration = /^[-+]?P(?!$)(?:(?:[-+]?\\d+Y)|(?:[-+]?\\d+[.,]\\d+Y$))?(?:(?:[-+]?\\d+M)|(?:[-+]?\\d+[.,]\\d+M$))?(?:(?:[-+]?\\d+W)|(?:[-+]?\\d+[.,]\\d+W$))?(?:(?:[-+]?\\d+D)|(?:[-+]?\\d+[.,]\\d+D$))?(?:T(?=[\\d+-])(?:(?:[-+]?\\d+H)|(?:[-+]?\\d+[.,]\\d+H$))?(?:(?:[-+]?\\d+M)|(?:[-+]?\\d+[.,]\\d+M$))?(?:[-+]?\\d+(?:[.,]\\d+)?S)?)??$/;\n var guid = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;\n var uuid = (version2) => {\n if (!version2)\n return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/;\n return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version2}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);\n };\n var uuid4 = /* @__PURE__ */ uuid(4);\n var uuid6 = /* @__PURE__ */ uuid(6);\n var uuid7 = /* @__PURE__ */ uuid(7);\n var email = /^(?!\\.)(?!.*\\.\\.)([A-Za-z0-9_'+\\-\\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\\-]*\\.)+[A-Za-z]{2,}$/;\n var html5Email = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;\n var rfc5322Email = /^(([^<>()\\[\\]\\\\.,;:\\s@\"]+(\\.[^<>()\\[\\]\\\\.,;:\\s@\"]+)*)|(\".+\"))@((\\[[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}])|(([a-zA-Z\\-0-9]+\\.)+[a-zA-Z]{2,}))$/;\n var unicodeEmail = /^[^\\s@\"]{1,64}@[^\\s@]{1,255}$/u;\n var idnEmail = unicodeEmail;\n var browserEmail = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;\n var _emoji = `^(\\\\p{Extended_Pictographic}|\\\\p{Emoji_Component})+$`;\n function emoji() {\n return new RegExp(_emoji, \"u\");\n }\n var ipv4 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;\n var ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/;\n var mac = (delimiter) => {\n const escapedDelim = escapeRegex(delimiter ?? \":\");\n return new RegExp(`^(?:[0-9A-F]{2}${escapedDelim}){5}[0-9A-F]{2}$|^(?:[0-9a-f]{2}${escapedDelim}){5}[0-9a-f]{2}$`);\n };\n var cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\/([0-9]|[1-2][0-9]|3[0-2])$/;\n var cidrv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})\\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;\n var base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;\n var base64url = /^[A-Za-z0-9_-]*$/;\n var hostname = /^(?=.{1,253}\\.?$)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[-0-9a-zA-Z]{0,61}[0-9a-zA-Z])?)*\\.?$/;\n var domain = /^([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\\.)+[a-zA-Z]{2,}$/;\n var e164 = /^\\+[1-9]\\d{6,14}$/;\n var dateSource = `(?:(?:\\\\d\\\\d[2468][048]|\\\\d\\\\d[13579][26]|\\\\d\\\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\\\d|30)|(?:02)-(?:0[1-9]|1\\\\d|2[0-8])))`;\n var date = /* @__PURE__ */ new RegExp(`^${dateSource}$`);\n function timeSource(args) {\n const hhmm = `(?:[01]\\\\d|2[0-3]):[0-5]\\\\d`;\n const regex = typeof args.precision === \"number\" ? args.precision === -1 ? `${hhmm}` : args.precision === 0 ? `${hhmm}:[0-5]\\\\d` : `${hhmm}:[0-5]\\\\d\\\\.\\\\d{${args.precision}}` : `${hhmm}(?::[0-5]\\\\d(?:\\\\.\\\\d+)?)?`;\n return regex;\n }\n function time(args) {\n return new RegExp(`^${timeSource(args)}$`);\n }\n function datetime(args) {\n const time3 = timeSource({ precision: args.precision });\n const opts = [\"Z\"];\n if (args.local)\n opts.push(\"\");\n if (args.offset)\n opts.push(`([+-](?:[01]\\\\d|2[0-3]):[0-5]\\\\d)`);\n const timeRegex = `${time3}(?:${opts.join(\"|\")})`;\n return new RegExp(`^${dateSource}T(?:${timeRegex})$`);\n }\n var string = (params) => {\n const regex = params ? `[\\\\s\\\\S]{${params?.minimum ?? 0},${params?.maximum ?? \"\"}}` : `[\\\\s\\\\S]*`;\n return new RegExp(`^${regex}$`);\n };\n var bigint = /^-?\\d+n?$/;\n var integer = /^-?\\d+$/;\n var number = /^-?\\d+(?:\\.\\d+)?$/;\n var boolean = /^(?:true|false)$/i;\n var _null = /^null$/i;\n var _undefined = /^undefined$/i;\n var lowercase = /^[^A-Z]*$/;\n var uppercase = /^[^a-z]*$/;\n var hex = /^[0-9a-fA-F]*$/;\n function fixedBase64(bodyLength, padding) {\n return new RegExp(`^[A-Za-z0-9+/]{${bodyLength}}${padding}$`);\n }\n function fixedBase64url(length) {\n return new RegExp(`^[A-Za-z0-9_-]{${length}}$`);\n }\n var md5_hex = /^[0-9a-fA-F]{32}$/;\n var md5_base64 = /* @__PURE__ */ fixedBase64(22, \"==\");\n var md5_base64url = /* @__PURE__ */ fixedBase64url(22);\n var sha1_hex = /^[0-9a-fA-F]{40}$/;\n var sha1_base64 = /* @__PURE__ */ fixedBase64(27, \"=\");\n var sha1_base64url = /* @__PURE__ */ fixedBase64url(27);\n var sha256_hex = /^[0-9a-fA-F]{64}$/;\n var sha256_base64 = /* @__PURE__ */ fixedBase64(43, \"=\");\n var sha256_base64url = /* @__PURE__ */ fixedBase64url(43);\n var sha384_hex = /^[0-9a-fA-F]{96}$/;\n var sha384_base64 = /* @__PURE__ */ fixedBase64(64, \"\");\n var sha384_base64url = /* @__PURE__ */ fixedBase64url(64);\n var sha512_hex = /^[0-9a-fA-F]{128}$/;\n var sha512_base64 = /* @__PURE__ */ fixedBase64(86, \"==\");\n var sha512_base64url = /* @__PURE__ */ fixedBase64url(86);\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/checks.js\n var $ZodCheck = /* @__PURE__ */ $constructor(\"$ZodCheck\", (inst, def) => {\n var _a2;\n inst._zod ?? (inst._zod = {});\n inst._zod.def = def;\n (_a2 = inst._zod).onattach ?? (_a2.onattach = []);\n });\n var numericOriginMap = {\n number: \"number\",\n bigint: \"bigint\",\n object: \"date\"\n };\n var $ZodCheckLessThan = /* @__PURE__ */ $constructor(\"$ZodCheckLessThan\", (inst, def) => {\n $ZodCheck.init(inst, def);\n const origin = numericOriginMap[typeof def.value];\n inst._zod.onattach.push((inst2) => {\n const bag = inst2._zod.bag;\n const curr = (def.inclusive ? bag.maximum : bag.exclusiveMaximum) ?? Number.POSITIVE_INFINITY;\n if (def.value < curr) {\n if (def.inclusive)\n bag.maximum = def.value;\n else\n bag.exclusiveMaximum = def.value;\n }\n });\n inst._zod.check = (payload) => {\n if (def.inclusive ? payload.value <= def.value : payload.value < def.value) {\n return;\n }\n payload.issues.push({\n origin,\n code: \"too_big\",\n maximum: typeof def.value === \"object\" ? def.value.getTime() : def.value,\n input: payload.value,\n inclusive: def.inclusive,\n inst,\n continue: !def.abort\n });\n };\n });\n var $ZodCheckGreaterThan = /* @__PURE__ */ $constructor(\"$ZodCheckGreaterThan\", (inst, def) => {\n $ZodCheck.init(inst, def);\n const origin = numericOriginMap[typeof def.value];\n inst._zod.onattach.push((inst2) => {\n const bag = inst2._zod.bag;\n const curr = (def.inclusive ? bag.minimum : bag.exclusiveMinimum) ?? Number.NEGATIVE_INFINITY;\n if (def.value > curr) {\n if (def.inclusive)\n bag.minimum = def.value;\n else\n bag.exclusiveMinimum = def.value;\n }\n });\n inst._zod.check = (payload) => {\n if (def.inclusive ? payload.value >= def.value : payload.value > def.value) {\n return;\n }\n payload.issues.push({\n origin,\n code: \"too_small\",\n minimum: typeof def.value === \"object\" ? def.value.getTime() : def.value,\n input: payload.value,\n inclusive: def.inclusive,\n inst,\n continue: !def.abort\n });\n };\n });\n var $ZodCheckMultipleOf = /* @__PURE__ */ $constructor(\"$ZodCheckMultipleOf\", (inst, def) => {\n $ZodCheck.init(inst, def);\n inst._zod.onattach.push((inst2) => {\n var _a2;\n (_a2 = inst2._zod.bag).multipleOf ?? (_a2.multipleOf = def.value);\n });\n inst._zod.check = (payload) => {\n if (typeof payload.value !== typeof def.value)\n throw new Error(\"Cannot mix number and bigint in multiple_of check.\");\n const isMultiple = typeof payload.value === \"bigint\" ? payload.value % def.value === BigInt(0) : floatSafeRemainder(payload.value, def.value) === 0;\n if (isMultiple)\n return;\n payload.issues.push({\n origin: typeof payload.value,\n code: \"not_multiple_of\",\n divisor: def.value,\n input: payload.value,\n inst,\n continue: !def.abort\n });\n };\n });\n var $ZodCheckNumberFormat = /* @__PURE__ */ $constructor(\"$ZodCheckNumberFormat\", (inst, def) => {\n $ZodCheck.init(inst, def);\n def.format = def.format || \"float64\";\n const isInt = def.format?.includes(\"int\");\n const origin = isInt ? \"int\" : \"number\";\n const [minimum, maximum] = NUMBER_FORMAT_RANGES[def.format];\n inst._zod.onattach.push((inst2) => {\n const bag = inst2._zod.bag;\n bag.format = def.format;\n bag.minimum = minimum;\n bag.maximum = maximum;\n if (isInt)\n bag.pattern = integer;\n });\n inst._zod.check = (payload) => {\n const input = payload.value;\n if (isInt) {\n if (!Number.isInteger(input)) {\n payload.issues.push({\n expected: origin,\n format: def.format,\n code: \"invalid_type\",\n continue: false,\n input,\n inst\n });\n return;\n }\n if (!Number.isSafeInteger(input)) {\n if (input > 0) {\n payload.issues.push({\n input,\n code: \"too_big\",\n maximum: Number.MAX_SAFE_INTEGER,\n note: \"Integers must be within the safe integer range.\",\n inst,\n origin,\n inclusive: true,\n continue: !def.abort\n });\n } else {\n payload.issues.push({\n input,\n code: \"too_small\",\n minimum: Number.MIN_SAFE_INTEGER,\n note: \"Integers must be within the safe integer range.\",\n inst,\n origin,\n inclusive: true,\n continue: !def.abort\n });\n }\n return;\n }\n }\n if (input < minimum) {\n payload.issues.push({\n origin: \"number\",\n input,\n code: \"too_small\",\n minimum,\n inclusive: true,\n inst,\n continue: !def.abort\n });\n }\n if (input > maximum) {\n payload.issues.push({\n origin: \"number\",\n input,\n code: \"too_big\",\n maximum,\n inclusive: true,\n inst,\n continue: !def.abort\n });\n }\n };\n });\n var $ZodCheckBigIntFormat = /* @__PURE__ */ $constructor(\"$ZodCheckBigIntFormat\", (inst, def) => {\n $ZodCheck.init(inst, def);\n const [minimum, maximum] = BIGINT_FORMAT_RANGES[def.format];\n inst._zod.onattach.push((inst2) => {\n const bag = inst2._zod.bag;\n bag.format = def.format;\n bag.minimum = minimum;\n bag.maximum = maximum;\n });\n inst._zod.check = (payload) => {\n const input = payload.value;\n if (input < minimum) {\n payload.issues.push({\n origin: \"bigint\",\n input,\n code: \"too_small\",\n minimum,\n inclusive: true,\n inst,\n continue: !def.abort\n });\n }\n if (input > maximum) {\n payload.issues.push({\n origin: \"bigint\",\n input,\n code: \"too_big\",\n maximum,\n inclusive: true,\n inst,\n continue: !def.abort\n });\n }\n };\n });\n var $ZodCheckMaxSize = /* @__PURE__ */ $constructor(\"$ZodCheckMaxSize\", (inst, def) => {\n var _a2;\n $ZodCheck.init(inst, def);\n (_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {\n const val = payload.value;\n return !nullish(val) && val.size !== void 0;\n });\n inst._zod.onattach.push((inst2) => {\n const curr = inst2._zod.bag.maximum ?? Number.POSITIVE_INFINITY;\n if (def.maximum < curr)\n inst2._zod.bag.maximum = def.maximum;\n });\n inst._zod.check = (payload) => {\n const input = payload.value;\n const size = input.size;\n if (size <= def.maximum)\n return;\n payload.issues.push({\n origin: getSizableOrigin(input),\n code: \"too_big\",\n maximum: def.maximum,\n inclusive: true,\n input,\n inst,\n continue: !def.abort\n });\n };\n });\n var $ZodCheckMinSize = /* @__PURE__ */ $constructor(\"$ZodCheckMinSize\", (inst, def) => {\n var _a2;\n $ZodCheck.init(inst, def);\n (_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {\n const val = payload.value;\n return !nullish(val) && val.size !== void 0;\n });\n inst._zod.onattach.push((inst2) => {\n const curr = inst2._zod.bag.minimum ?? Number.NEGATIVE_INFINITY;\n if (def.minimum > curr)\n inst2._zod.bag.minimum = def.minimum;\n });\n inst._zod.check = (payload) => {\n const input = payload.value;\n const size = input.size;\n if (size >= def.minimum)\n return;\n payload.issues.push({\n origin: getSizableOrigin(input),\n code: \"too_small\",\n minimum: def.minimum,\n inclusive: true,\n input,\n inst,\n continue: !def.abort\n });\n };\n });\n var $ZodCheckSizeEquals = /* @__PURE__ */ $constructor(\"$ZodCheckSizeEquals\", (inst, def) => {\n var _a2;\n $ZodCheck.init(inst, def);\n (_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {\n const val = payload.value;\n return !nullish(val) && val.size !== void 0;\n });\n inst._zod.onattach.push((inst2) => {\n const bag = inst2._zod.bag;\n bag.minimum = def.size;\n bag.maximum = def.size;\n bag.size = def.size;\n });\n inst._zod.check = (payload) => {\n const input = payload.value;\n const size = input.size;\n if (size === def.size)\n return;\n const tooBig = size > def.size;\n payload.issues.push({\n origin: getSizableOrigin(input),\n ...tooBig ? { code: \"too_big\", maximum: def.size } : { code: \"too_small\", minimum: def.size },\n inclusive: true,\n exact: true,\n input: payload.value,\n inst,\n continue: !def.abort\n });\n };\n });\n var $ZodCheckMaxLength = /* @__PURE__ */ $constructor(\"$ZodCheckMaxLength\", (inst, def) => {\n var _a2;\n $ZodCheck.init(inst, def);\n (_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {\n const val = payload.value;\n return !nullish(val) && val.length !== void 0;\n });\n inst._zod.onattach.push((inst2) => {\n const curr = inst2._zod.bag.maximum ?? Number.POSITIVE_INFINITY;\n if (def.maximum < curr)\n inst2._zod.bag.maximum = def.maximum;\n });\n inst._zod.check = (payload) => {\n const input = payload.value;\n const length = input.length;\n if (length <= def.maximum)\n return;\n const origin = getLengthableOrigin(input);\n payload.issues.push({\n origin,\n code: \"too_big\",\n maximum: def.maximum,\n inclusive: true,\n input,\n inst,\n continue: !def.abort\n });\n };\n });\n var $ZodCheckMinLength = /* @__PURE__ */ $constructor(\"$ZodCheckMinLength\", (inst, def) => {\n var _a2;\n $ZodCheck.init(inst, def);\n (_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {\n const val = payload.value;\n return !nullish(val) && val.length !== void 0;\n });\n inst._zod.onattach.push((inst2) => {\n const curr = inst2._zod.bag.minimum ?? Number.NEGATIVE_INFINITY;\n if (def.minimum > curr)\n inst2._zod.bag.minimum = def.minimum;\n });\n inst._zod.check = (payload) => {\n const input = payload.value;\n const length = input.length;\n if (length >= def.minimum)\n return;\n const origin = getLengthableOrigin(input);\n payload.issues.push({\n origin,\n code: \"too_small\",\n minimum: def.minimum,\n inclusive: true,\n input,\n inst,\n continue: !def.abort\n });\n };\n });\n var $ZodCheckLengthEquals = /* @__PURE__ */ $constructor(\"$ZodCheckLengthEquals\", (inst, def) => {\n var _a2;\n $ZodCheck.init(inst, def);\n (_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {\n const val = payload.value;\n return !nullish(val) && val.length !== void 0;\n });\n inst._zod.onattach.push((inst2) => {\n const bag = inst2._zod.bag;\n bag.minimum = def.length;\n bag.maximum = def.length;\n bag.length = def.length;\n });\n inst._zod.check = (payload) => {\n const input = payload.value;\n const length = input.length;\n if (length === def.length)\n return;\n const origin = getLengthableOrigin(input);\n const tooBig = length > def.length;\n payload.issues.push({\n origin,\n ...tooBig ? { code: \"too_big\", maximum: def.length } : { code: \"too_small\", minimum: def.length },\n inclusive: true,\n exact: true,\n input: payload.value,\n inst,\n continue: !def.abort\n });\n };\n });\n var $ZodCheckStringFormat = /* @__PURE__ */ $constructor(\"$ZodCheckStringFormat\", (inst, def) => {\n var _a2, _b;\n $ZodCheck.init(inst, def);\n inst._zod.onattach.push((inst2) => {\n const bag = inst2._zod.bag;\n bag.format = def.format;\n if (def.pattern) {\n bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set());\n bag.patterns.add(def.pattern);\n }\n });\n if (def.pattern)\n (_a2 = inst._zod).check ?? (_a2.check = (payload) => {\n def.pattern.lastIndex = 0;\n if (def.pattern.test(payload.value))\n return;\n payload.issues.push({\n origin: \"string\",\n code: \"invalid_format\",\n format: def.format,\n input: payload.value,\n ...def.pattern ? { pattern: def.pattern.toString() } : {},\n inst,\n continue: !def.abort\n });\n });\n else\n (_b = inst._zod).check ?? (_b.check = () => {\n });\n });\n var $ZodCheckRegex = /* @__PURE__ */ $constructor(\"$ZodCheckRegex\", (inst, def) => {\n $ZodCheckStringFormat.init(inst, def);\n inst._zod.check = (payload) => {\n def.pattern.lastIndex = 0;\n if (def.pattern.test(payload.value))\n return;\n payload.issues.push({\n origin: \"string\",\n code: \"invalid_format\",\n format: \"regex\",\n input: payload.value,\n pattern: def.pattern.toString(),\n inst,\n continue: !def.abort\n });\n };\n });\n var $ZodCheckLowerCase = /* @__PURE__ */ $constructor(\"$ZodCheckLowerCase\", (inst, def) => {\n def.pattern ?? (def.pattern = lowercase);\n $ZodCheckStringFormat.init(inst, def);\n });\n var $ZodCheckUpperCase = /* @__PURE__ */ $constructor(\"$ZodCheckUpperCase\", (inst, def) => {\n def.pattern ?? (def.pattern = uppercase);\n $ZodCheckStringFormat.init(inst, def);\n });\n var $ZodCheckIncludes = /* @__PURE__ */ $constructor(\"$ZodCheckIncludes\", (inst, def) => {\n $ZodCheck.init(inst, def);\n const escapedRegex = escapeRegex(def.includes);\n const pattern = new RegExp(typeof def.position === \"number\" ? `^.{${def.position}}${escapedRegex}` : escapedRegex);\n def.pattern = pattern;\n inst._zod.onattach.push((inst2) => {\n const bag = inst2._zod.bag;\n bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set());\n bag.patterns.add(pattern);\n });\n inst._zod.check = (payload) => {\n if (payload.value.includes(def.includes, def.position))\n return;\n payload.issues.push({\n origin: \"string\",\n code: \"invalid_format\",\n format: \"includes\",\n includes: def.includes,\n input: payload.value,\n inst,\n continue: !def.abort\n });\n };\n });\n var $ZodCheckStartsWith = /* @__PURE__ */ $constructor(\"$ZodCheckStartsWith\", (inst, def) => {\n $ZodCheck.init(inst, def);\n const pattern = new RegExp(`^${escapeRegex(def.prefix)}.*`);\n def.pattern ?? (def.pattern = pattern);\n inst._zod.onattach.push((inst2) => {\n const bag = inst2._zod.bag;\n bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set());\n bag.patterns.add(pattern);\n });\n inst._zod.check = (payload) => {\n if (payload.value.startsWith(def.prefix))\n return;\n payload.issues.push({\n origin: \"string\",\n code: \"invalid_format\",\n format: \"starts_with\",\n prefix: def.prefix,\n input: payload.value,\n inst,\n continue: !def.abort\n });\n };\n });\n var $ZodCheckEndsWith = /* @__PURE__ */ $constructor(\"$ZodCheckEndsWith\", (inst, def) => {\n $ZodCheck.init(inst, def);\n const pattern = new RegExp(`.*${escapeRegex(def.suffix)}$`);\n def.pattern ?? (def.pattern = pattern);\n inst._zod.onattach.push((inst2) => {\n const bag = inst2._zod.bag;\n bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set());\n bag.patterns.add(pattern);\n });\n inst._zod.check = (payload) => {\n if (payload.value.endsWith(def.suffix))\n return;\n payload.issues.push({\n origin: \"string\",\n code: \"invalid_format\",\n format: \"ends_with\",\n suffix: def.suffix,\n input: payload.value,\n inst,\n continue: !def.abort\n });\n };\n });\n function handleCheckPropertyResult(result, payload, property) {\n if (result.issues.length) {\n payload.issues.push(...prefixIssues(property, result.issues));\n }\n }\n var $ZodCheckProperty = /* @__PURE__ */ $constructor(\"$ZodCheckProperty\", (inst, def) => {\n $ZodCheck.init(inst, def);\n inst._zod.check = (payload) => {\n const result = def.schema._zod.run({\n value: payload.value[def.property],\n issues: []\n }, {});\n if (result instanceof Promise) {\n return result.then((result2) => handleCheckPropertyResult(result2, payload, def.property));\n }\n handleCheckPropertyResult(result, payload, def.property);\n return;\n };\n });\n var $ZodCheckMimeType = /* @__PURE__ */ $constructor(\"$ZodCheckMimeType\", (inst, def) => {\n $ZodCheck.init(inst, def);\n const mimeSet = new Set(def.mime);\n inst._zod.onattach.push((inst2) => {\n inst2._zod.bag.mime = def.mime;\n });\n inst._zod.check = (payload) => {\n if (mimeSet.has(payload.value.type))\n return;\n payload.issues.push({\n code: \"invalid_value\",\n values: def.mime,\n input: payload.value.type,\n inst,\n continue: !def.abort\n });\n };\n });\n var $ZodCheckOverwrite = /* @__PURE__ */ $constructor(\"$ZodCheckOverwrite\", (inst, def) => {\n $ZodCheck.init(inst, def);\n inst._zod.check = (payload) => {\n payload.value = def.tx(payload.value);\n };\n });\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/doc.js\n var Doc = class {\n constructor(args = []) {\n this.content = [];\n this.indent = 0;\n if (this)\n this.args = args;\n }\n indented(fn) {\n this.indent += 1;\n fn(this);\n this.indent -= 1;\n }\n write(arg) {\n if (typeof arg === \"function\") {\n arg(this, { execution: \"sync\" });\n arg(this, { execution: \"async\" });\n return;\n }\n const content = arg;\n const lines = content.split(\"\\n\").filter((x) => x);\n const minIndent = Math.min(...lines.map((x) => x.length - x.trimStart().length));\n const dedented = lines.map((x) => x.slice(minIndent)).map((x) => \" \".repeat(this.indent * 2) + x);\n for (const line of dedented) {\n this.content.push(line);\n }\n }\n compile() {\n const F = Function;\n const args = this?.args;\n const content = this?.content ?? [``];\n const lines = [...content.map((x) => ` ${x}`)];\n return new F(...args, lines.join(\"\\n\"));\n }\n };\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/versions.js\n var version = {\n major: 4,\n minor: 3,\n patch: 6\n };\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/schemas.js\n var $ZodType = /* @__PURE__ */ $constructor(\"$ZodType\", (inst, def) => {\n var _a2;\n inst ?? (inst = {});\n inst._zod.def = def;\n inst._zod.bag = inst._zod.bag || {};\n inst._zod.version = version;\n const checks = [...inst._zod.def.checks ?? []];\n if (inst._zod.traits.has(\"$ZodCheck\")) {\n checks.unshift(inst);\n }\n for (const ch of checks) {\n for (const fn of ch._zod.onattach) {\n fn(inst);\n }\n }\n if (checks.length === 0) {\n (_a2 = inst._zod).deferred ?? (_a2.deferred = []);\n inst._zod.deferred?.push(() => {\n inst._zod.run = inst._zod.parse;\n });\n } else {\n const runChecks = (payload, checks2, ctx) => {\n let isAborted = aborted(payload);\n let asyncResult;\n for (const ch of checks2) {\n if (ch._zod.def.when) {\n const shouldRun = ch._zod.def.when(payload);\n if (!shouldRun)\n continue;\n } else if (isAborted) {\n continue;\n }\n const currLen = payload.issues.length;\n const _ = ch._zod.check(payload);\n if (_ instanceof Promise && ctx?.async === false) {\n throw new $ZodAsyncError();\n }\n if (asyncResult || _ instanceof Promise) {\n asyncResult = (asyncResult ?? Promise.resolve()).then(async () => {\n await _;\n const nextLen = payload.issues.length;\n if (nextLen === currLen)\n return;\n if (!isAborted)\n isAborted = aborted(payload, currLen);\n });\n } else {\n const nextLen = payload.issues.length;\n if (nextLen === currLen)\n continue;\n if (!isAborted)\n isAborted = aborted(payload, currLen);\n }\n }\n if (asyncResult) {\n return asyncResult.then(() => {\n return payload;\n });\n }\n return payload;\n };\n const handleCanaryResult = (canary, payload, ctx) => {\n if (aborted(canary)) {\n canary.aborted = true;\n return canary;\n }\n const checkResult = runChecks(payload, checks, ctx);\n if (checkResult instanceof Promise) {\n if (ctx.async === false)\n throw new $ZodAsyncError();\n return checkResult.then((checkResult2) => inst._zod.parse(checkResult2, ctx));\n }\n return inst._zod.parse(checkResult, ctx);\n };\n inst._zod.run = (payload, ctx) => {\n if (ctx.skipChecks) {\n return inst._zod.parse(payload, ctx);\n }\n if (ctx.direction === \"backward\") {\n const canary = inst._zod.parse({ value: payload.value, issues: [] }, { ...ctx, skipChecks: true });\n if (canary instanceof Promise) {\n return canary.then((canary2) => {\n return handleCanaryResult(canary2, payload, ctx);\n });\n }\n return handleCanaryResult(canary, payload, ctx);\n }\n const result = inst._zod.parse(payload, ctx);\n if (result instanceof Promise) {\n if (ctx.async === false)\n throw new $ZodAsyncError();\n return result.then((result2) => runChecks(result2, checks, ctx));\n }\n return runChecks(result, checks, ctx);\n };\n }\n defineLazy(inst, \"~standard\", () => ({\n validate: (value) => {\n try {\n const r = safeParse(inst, value);\n return r.success ? { value: r.data } : { issues: r.error?.issues };\n } catch (_) {\n return safeParseAsync(inst, value).then((r) => r.success ? { value: r.data } : { issues: r.error?.issues });\n }\n },\n vendor: \"zod\",\n version: 1\n }));\n });\n var $ZodString = /* @__PURE__ */ $constructor(\"$ZodString\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.pattern = [...inst?._zod.bag?.patterns ?? []].pop() ?? string(inst._zod.bag);\n inst._zod.parse = (payload, _) => {\n if (def.coerce)\n try {\n payload.value = String(payload.value);\n } catch (_2) {\n }\n if (typeof payload.value === \"string\")\n return payload;\n payload.issues.push({\n expected: \"string\",\n code: \"invalid_type\",\n input: payload.value,\n inst\n });\n return payload;\n };\n });\n var $ZodStringFormat = /* @__PURE__ */ $constructor(\"$ZodStringFormat\", (inst, def) => {\n $ZodCheckStringFormat.init(inst, def);\n $ZodString.init(inst, def);\n });\n var $ZodGUID = /* @__PURE__ */ $constructor(\"$ZodGUID\", (inst, def) => {\n def.pattern ?? (def.pattern = guid);\n $ZodStringFormat.init(inst, def);\n });\n var $ZodUUID = /* @__PURE__ */ $constructor(\"$ZodUUID\", (inst, def) => {\n if (def.version) {\n const versionMap = {\n v1: 1,\n v2: 2,\n v3: 3,\n v4: 4,\n v5: 5,\n v6: 6,\n v7: 7,\n v8: 8\n };\n const v = versionMap[def.version];\n if (v === void 0)\n throw new Error(`Invalid UUID version: \"${def.version}\"`);\n def.pattern ?? (def.pattern = uuid(v));\n } else\n def.pattern ?? (def.pattern = uuid());\n $ZodStringFormat.init(inst, def);\n });\n var $ZodEmail = /* @__PURE__ */ $constructor(\"$ZodEmail\", (inst, def) => {\n def.pattern ?? (def.pattern = email);\n $ZodStringFormat.init(inst, def);\n });\n var $ZodURL = /* @__PURE__ */ $constructor(\"$ZodURL\", (inst, def) => {\n $ZodStringFormat.init(inst, def);\n inst._zod.check = (payload) => {\n try {\n const trimmed = payload.value.trim();\n const url2 = new URL(trimmed);\n if (def.hostname) {\n def.hostname.lastIndex = 0;\n if (!def.hostname.test(url2.hostname)) {\n payload.issues.push({\n code: \"invalid_format\",\n format: \"url\",\n note: \"Invalid hostname\",\n pattern: def.hostname.source,\n input: payload.value,\n inst,\n continue: !def.abort\n });\n }\n }\n if (def.protocol) {\n def.protocol.lastIndex = 0;\n if (!def.protocol.test(url2.protocol.endsWith(\":\") ? url2.protocol.slice(0, -1) : url2.protocol)) {\n payload.issues.push({\n code: \"invalid_format\",\n format: \"url\",\n note: \"Invalid protocol\",\n pattern: def.protocol.source,\n input: payload.value,\n inst,\n continue: !def.abort\n });\n }\n }\n if (def.normalize) {\n payload.value = url2.href;\n } else {\n payload.value = trimmed;\n }\n return;\n } catch (_) {\n payload.issues.push({\n code: \"invalid_format\",\n format: \"url\",\n input: payload.value,\n inst,\n continue: !def.abort\n });\n }\n };\n });\n var $ZodEmoji = /* @__PURE__ */ $constructor(\"$ZodEmoji\", (inst, def) => {\n def.pattern ?? (def.pattern = emoji());\n $ZodStringFormat.init(inst, def);\n });\n var $ZodNanoID = /* @__PURE__ */ $constructor(\"$ZodNanoID\", (inst, def) => {\n def.pattern ?? (def.pattern = nanoid);\n $ZodStringFormat.init(inst, def);\n });\n var $ZodCUID = /* @__PURE__ */ $constructor(\"$ZodCUID\", (inst, def) => {\n def.pattern ?? (def.pattern = cuid);\n $ZodStringFormat.init(inst, def);\n });\n var $ZodCUID2 = /* @__PURE__ */ $constructor(\"$ZodCUID2\", (inst, def) => {\n def.pattern ?? (def.pattern = cuid2);\n $ZodStringFormat.init(inst, def);\n });\n var $ZodULID = /* @__PURE__ */ $constructor(\"$ZodULID\", (inst, def) => {\n def.pattern ?? (def.pattern = ulid);\n $ZodStringFormat.init(inst, def);\n });\n var $ZodXID = /* @__PURE__ */ $constructor(\"$ZodXID\", (inst, def) => {\n def.pattern ?? (def.pattern = xid);\n $ZodStringFormat.init(inst, def);\n });\n var $ZodKSUID = /* @__PURE__ */ $constructor(\"$ZodKSUID\", (inst, def) => {\n def.pattern ?? (def.pattern = ksuid);\n $ZodStringFormat.init(inst, def);\n });\n var $ZodISODateTime = /* @__PURE__ */ $constructor(\"$ZodISODateTime\", (inst, def) => {\n def.pattern ?? (def.pattern = datetime(def));\n $ZodStringFormat.init(inst, def);\n });\n var $ZodISODate = /* @__PURE__ */ $constructor(\"$ZodISODate\", (inst, def) => {\n def.pattern ?? (def.pattern = date);\n $ZodStringFormat.init(inst, def);\n });\n var $ZodISOTime = /* @__PURE__ */ $constructor(\"$ZodISOTime\", (inst, def) => {\n def.pattern ?? (def.pattern = time(def));\n $ZodStringFormat.init(inst, def);\n });\n var $ZodISODuration = /* @__PURE__ */ $constructor(\"$ZodISODuration\", (inst, def) => {\n def.pattern ?? (def.pattern = duration);\n $ZodStringFormat.init(inst, def);\n });\n var $ZodIPv4 = /* @__PURE__ */ $constructor(\"$ZodIPv4\", (inst, def) => {\n def.pattern ?? (def.pattern = ipv4);\n $ZodStringFormat.init(inst, def);\n inst._zod.bag.format = `ipv4`;\n });\n var $ZodIPv6 = /* @__PURE__ */ $constructor(\"$ZodIPv6\", (inst, def) => {\n def.pattern ?? (def.pattern = ipv6);\n $ZodStringFormat.init(inst, def);\n inst._zod.bag.format = `ipv6`;\n inst._zod.check = (payload) => {\n try {\n new URL(`http://[${payload.value}]`);\n } catch {\n payload.issues.push({\n code: \"invalid_format\",\n format: \"ipv6\",\n input: payload.value,\n inst,\n continue: !def.abort\n });\n }\n };\n });\n var $ZodMAC = /* @__PURE__ */ $constructor(\"$ZodMAC\", (inst, def) => {\n def.pattern ?? (def.pattern = mac(def.delimiter));\n $ZodStringFormat.init(inst, def);\n inst._zod.bag.format = `mac`;\n });\n var $ZodCIDRv4 = /* @__PURE__ */ $constructor(\"$ZodCIDRv4\", (inst, def) => {\n def.pattern ?? (def.pattern = cidrv4);\n $ZodStringFormat.init(inst, def);\n });\n var $ZodCIDRv6 = /* @__PURE__ */ $constructor(\"$ZodCIDRv6\", (inst, def) => {\n def.pattern ?? (def.pattern = cidrv6);\n $ZodStringFormat.init(inst, def);\n inst._zod.check = (payload) => {\n const parts = payload.value.split(\"/\");\n try {\n if (parts.length !== 2)\n throw new Error();\n const [address, prefix] = parts;\n if (!prefix)\n throw new Error();\n const prefixNum = Number(prefix);\n if (`${prefixNum}` !== prefix)\n throw new Error();\n if (prefixNum < 0 || prefixNum > 128)\n throw new Error();\n new URL(`http://[${address}]`);\n } catch {\n payload.issues.push({\n code: \"invalid_format\",\n format: \"cidrv6\",\n input: payload.value,\n inst,\n continue: !def.abort\n });\n }\n };\n });\n function isValidBase64(data) {\n if (data === \"\")\n return true;\n if (data.length % 4 !== 0)\n return false;\n try {\n atob(data);\n return true;\n } catch {\n return false;\n }\n }\n var $ZodBase64 = /* @__PURE__ */ $constructor(\"$ZodBase64\", (inst, def) => {\n def.pattern ?? (def.pattern = base64);\n $ZodStringFormat.init(inst, def);\n inst._zod.bag.contentEncoding = \"base64\";\n inst._zod.check = (payload) => {\n if (isValidBase64(payload.value))\n return;\n payload.issues.push({\n code: \"invalid_format\",\n format: \"base64\",\n input: payload.value,\n inst,\n continue: !def.abort\n });\n };\n });\n function isValidBase64URL(data) {\n if (!base64url.test(data))\n return false;\n const base643 = data.replace(/[-_]/g, (c) => c === \"-\" ? \"+\" : \"/\");\n const padded = base643.padEnd(Math.ceil(base643.length / 4) * 4, \"=\");\n return isValidBase64(padded);\n }\n var $ZodBase64URL = /* @__PURE__ */ $constructor(\"$ZodBase64URL\", (inst, def) => {\n def.pattern ?? (def.pattern = base64url);\n $ZodStringFormat.init(inst, def);\n inst._zod.bag.contentEncoding = \"base64url\";\n inst._zod.check = (payload) => {\n if (isValidBase64URL(payload.value))\n return;\n payload.issues.push({\n code: \"invalid_format\",\n format: \"base64url\",\n input: payload.value,\n inst,\n continue: !def.abort\n });\n };\n });\n var $ZodE164 = /* @__PURE__ */ $constructor(\"$ZodE164\", (inst, def) => {\n def.pattern ?? (def.pattern = e164);\n $ZodStringFormat.init(inst, def);\n });\n function isValidJWT(token, algorithm = null) {\n try {\n const tokensParts = token.split(\".\");\n if (tokensParts.length !== 3)\n return false;\n const [header] = tokensParts;\n if (!header)\n return false;\n const parsedHeader = JSON.parse(atob(header));\n if (\"typ\" in parsedHeader && parsedHeader?.typ !== \"JWT\")\n return false;\n if (!parsedHeader.alg)\n return false;\n if (algorithm && (!(\"alg\" in parsedHeader) || parsedHeader.alg !== algorithm))\n return false;\n return true;\n } catch {\n return false;\n }\n }\n var $ZodJWT = /* @__PURE__ */ $constructor(\"$ZodJWT\", (inst, def) => {\n $ZodStringFormat.init(inst, def);\n inst._zod.check = (payload) => {\n if (isValidJWT(payload.value, def.alg))\n return;\n payload.issues.push({\n code: \"invalid_format\",\n format: \"jwt\",\n input: payload.value,\n inst,\n continue: !def.abort\n });\n };\n });\n var $ZodCustomStringFormat = /* @__PURE__ */ $constructor(\"$ZodCustomStringFormat\", (inst, def) => {\n $ZodStringFormat.init(inst, def);\n inst._zod.check = (payload) => {\n if (def.fn(payload.value))\n return;\n payload.issues.push({\n code: \"invalid_format\",\n format: def.format,\n input: payload.value,\n inst,\n continue: !def.abort\n });\n };\n });\n var $ZodNumber = /* @__PURE__ */ $constructor(\"$ZodNumber\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.pattern = inst._zod.bag.pattern ?? number;\n inst._zod.parse = (payload, _ctx) => {\n if (def.coerce)\n try {\n payload.value = Number(payload.value);\n } catch (_) {\n }\n const input = payload.value;\n if (typeof input === \"number\" && !Number.isNaN(input) && Number.isFinite(input)) {\n return payload;\n }\n const received = typeof input === \"number\" ? Number.isNaN(input) ? \"NaN\" : !Number.isFinite(input) ? \"Infinity\" : void 0 : void 0;\n payload.issues.push({\n expected: \"number\",\n code: \"invalid_type\",\n input,\n inst,\n ...received ? { received } : {}\n });\n return payload;\n };\n });\n var $ZodNumberFormat = /* @__PURE__ */ $constructor(\"$ZodNumberFormat\", (inst, def) => {\n $ZodCheckNumberFormat.init(inst, def);\n $ZodNumber.init(inst, def);\n });\n var $ZodBoolean = /* @__PURE__ */ $constructor(\"$ZodBoolean\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.pattern = boolean;\n inst._zod.parse = (payload, _ctx) => {\n if (def.coerce)\n try {\n payload.value = Boolean(payload.value);\n } catch (_) {\n }\n const input = payload.value;\n if (typeof input === \"boolean\")\n return payload;\n payload.issues.push({\n expected: \"boolean\",\n code: \"invalid_type\",\n input,\n inst\n });\n return payload;\n };\n });\n var $ZodBigInt = /* @__PURE__ */ $constructor(\"$ZodBigInt\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.pattern = bigint;\n inst._zod.parse = (payload, _ctx) => {\n if (def.coerce)\n try {\n payload.value = BigInt(payload.value);\n } catch (_) {\n }\n if (typeof payload.value === \"bigint\")\n return payload;\n payload.issues.push({\n expected: \"bigint\",\n code: \"invalid_type\",\n input: payload.value,\n inst\n });\n return payload;\n };\n });\n var $ZodBigIntFormat = /* @__PURE__ */ $constructor(\"$ZodBigIntFormat\", (inst, def) => {\n $ZodCheckBigIntFormat.init(inst, def);\n $ZodBigInt.init(inst, def);\n });\n var $ZodSymbol = /* @__PURE__ */ $constructor(\"$ZodSymbol\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.parse = (payload, _ctx) => {\n const input = payload.value;\n if (typeof input === \"symbol\")\n return payload;\n payload.issues.push({\n expected: \"symbol\",\n code: \"invalid_type\",\n input,\n inst\n });\n return payload;\n };\n });\n var $ZodUndefined = /* @__PURE__ */ $constructor(\"$ZodUndefined\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.pattern = _undefined;\n inst._zod.values = /* @__PURE__ */ new Set([void 0]);\n inst._zod.optin = \"optional\";\n inst._zod.optout = \"optional\";\n inst._zod.parse = (payload, _ctx) => {\n const input = payload.value;\n if (typeof input === \"undefined\")\n return payload;\n payload.issues.push({\n expected: \"undefined\",\n code: \"invalid_type\",\n input,\n inst\n });\n return payload;\n };\n });\n var $ZodNull = /* @__PURE__ */ $constructor(\"$ZodNull\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.pattern = _null;\n inst._zod.values = /* @__PURE__ */ new Set([null]);\n inst._zod.parse = (payload, _ctx) => {\n const input = payload.value;\n if (input === null)\n return payload;\n payload.issues.push({\n expected: \"null\",\n code: \"invalid_type\",\n input,\n inst\n });\n return payload;\n };\n });\n var $ZodAny = /* @__PURE__ */ $constructor(\"$ZodAny\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.parse = (payload) => payload;\n });\n var $ZodUnknown = /* @__PURE__ */ $constructor(\"$ZodUnknown\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.parse = (payload) => payload;\n });\n var $ZodNever = /* @__PURE__ */ $constructor(\"$ZodNever\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.parse = (payload, _ctx) => {\n payload.issues.push({\n expected: \"never\",\n code: \"invalid_type\",\n input: payload.value,\n inst\n });\n return payload;\n };\n });\n var $ZodVoid = /* @__PURE__ */ $constructor(\"$ZodVoid\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.parse = (payload, _ctx) => {\n const input = payload.value;\n if (typeof input === \"undefined\")\n return payload;\n payload.issues.push({\n expected: \"void\",\n code: \"invalid_type\",\n input,\n inst\n });\n return payload;\n };\n });\n var $ZodDate = /* @__PURE__ */ $constructor(\"$ZodDate\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.parse = (payload, _ctx) => {\n if (def.coerce) {\n try {\n payload.value = new Date(payload.value);\n } catch (_err) {\n }\n }\n const input = payload.value;\n const isDate = input instanceof Date;\n const isValidDate = isDate && !Number.isNaN(input.getTime());\n if (isValidDate)\n return payload;\n payload.issues.push({\n expected: \"date\",\n code: \"invalid_type\",\n input,\n ...isDate ? { received: \"Invalid Date\" } : {},\n inst\n });\n return payload;\n };\n });\n function handleArrayResult(result, final, index) {\n if (result.issues.length) {\n final.issues.push(...prefixIssues(index, result.issues));\n }\n final.value[index] = result.value;\n }\n var $ZodArray = /* @__PURE__ */ $constructor(\"$ZodArray\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.parse = (payload, ctx) => {\n const input = payload.value;\n if (!Array.isArray(input)) {\n payload.issues.push({\n expected: \"array\",\n code: \"invalid_type\",\n input,\n inst\n });\n return payload;\n }\n payload.value = Array(input.length);\n const proms = [];\n for (let i = 0; i < input.length; i++) {\n const item = input[i];\n const result = def.element._zod.run({\n value: item,\n issues: []\n }, ctx);\n if (result instanceof Promise) {\n proms.push(result.then((result2) => handleArrayResult(result2, payload, i)));\n } else {\n handleArrayResult(result, payload, i);\n }\n }\n if (proms.length) {\n return Promise.all(proms).then(() => payload);\n }\n return payload;\n };\n });\n function handlePropertyResult(result, final, key, input, isOptionalOut) {\n if (result.issues.length) {\n if (isOptionalOut && !(key in input)) {\n return;\n }\n final.issues.push(...prefixIssues(key, result.issues));\n }\n if (result.value === void 0) {\n if (key in input) {\n final.value[key] = void 0;\n }\n } else {\n final.value[key] = result.value;\n }\n }\n function normalizeDef(def) {\n const keys = Object.keys(def.shape);\n for (const k of keys) {\n if (!def.shape?.[k]?._zod?.traits?.has(\"$ZodType\")) {\n throw new Error(`Invalid element at key \"${k}\": expected a Zod schema`);\n }\n }\n const okeys = optionalKeys(def.shape);\n return {\n ...def,\n keys,\n keySet: new Set(keys),\n numKeys: keys.length,\n optionalKeys: new Set(okeys)\n };\n }\n function handleCatchall(proms, input, payload, ctx, def, inst) {\n const unrecognized = [];\n const keySet = def.keySet;\n const _catchall = def.catchall._zod;\n const t = _catchall.def.type;\n const isOptionalOut = _catchall.optout === \"optional\";\n for (const key in input) {\n if (keySet.has(key))\n continue;\n if (t === \"never\") {\n unrecognized.push(key);\n continue;\n }\n const r = _catchall.run({ value: input[key], issues: [] }, ctx);\n if (r instanceof Promise) {\n proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input, isOptionalOut)));\n } else {\n handlePropertyResult(r, payload, key, input, isOptionalOut);\n }\n }\n if (unrecognized.length) {\n payload.issues.push({\n code: \"unrecognized_keys\",\n keys: unrecognized,\n input,\n inst\n });\n }\n if (!proms.length)\n return payload;\n return Promise.all(proms).then(() => {\n return payload;\n });\n }\n var $ZodObject = /* @__PURE__ */ $constructor(\"$ZodObject\", (inst, def) => {\n $ZodType.init(inst, def);\n const desc = Object.getOwnPropertyDescriptor(def, \"shape\");\n if (!desc?.get) {\n const sh = def.shape;\n Object.defineProperty(def, \"shape\", {\n get: () => {\n const newSh = { ...sh };\n Object.defineProperty(def, \"shape\", {\n value: newSh\n });\n return newSh;\n }\n });\n }\n const _normalized = cached(() => normalizeDef(def));\n defineLazy(inst._zod, \"propValues\", () => {\n const shape = def.shape;\n const propValues = {};\n for (const key in shape) {\n const field = shape[key]._zod;\n if (field.values) {\n propValues[key] ?? (propValues[key] = /* @__PURE__ */ new Set());\n for (const v of field.values)\n propValues[key].add(v);\n }\n }\n return propValues;\n });\n const isObject3 = isObject;\n const catchall = def.catchall;\n let value;\n inst._zod.parse = (payload, ctx) => {\n value ?? (value = _normalized.value);\n const input = payload.value;\n if (!isObject3(input)) {\n payload.issues.push({\n expected: \"object\",\n code: \"invalid_type\",\n input,\n inst\n });\n return payload;\n }\n payload.value = {};\n const proms = [];\n const shape = value.shape;\n for (const key of value.keys) {\n const el = shape[key];\n const isOptionalOut = el._zod.optout === \"optional\";\n const r = el._zod.run({ value: input[key], issues: [] }, ctx);\n if (r instanceof Promise) {\n proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input, isOptionalOut)));\n } else {\n handlePropertyResult(r, payload, key, input, isOptionalOut);\n }\n }\n if (!catchall) {\n return proms.length ? Promise.all(proms).then(() => payload) : payload;\n }\n return handleCatchall(proms, input, payload, ctx, _normalized.value, inst);\n };\n });\n var $ZodObjectJIT = /* @__PURE__ */ $constructor(\"$ZodObjectJIT\", (inst, def) => {\n $ZodObject.init(inst, def);\n const superParse = inst._zod.parse;\n const _normalized = cached(() => normalizeDef(def));\n const generateFastpass = (shape) => {\n const doc = new Doc([\"shape\", \"payload\", \"ctx\"]);\n const normalized = _normalized.value;\n const parseStr = (key) => {\n const k = esc(key);\n return `shape[${k}]._zod.run({ value: input[${k}], issues: [] }, ctx)`;\n };\n doc.write(`const input = payload.value;`);\n const ids = /* @__PURE__ */ Object.create(null);\n let counter = 0;\n for (const key of normalized.keys) {\n ids[key] = `key_${counter++}`;\n }\n doc.write(`const newResult = {};`);\n for (const key of normalized.keys) {\n const id = ids[key];\n const k = esc(key);\n const schema = shape[key];\n const isOptionalOut = schema?._zod?.optout === \"optional\";\n doc.write(`const ${id} = ${parseStr(key)};`);\n if (isOptionalOut) {\n doc.write(`\n if (${id}.issues.length) {\n if (${k} in input) {\n payload.issues = payload.issues.concat(${id}.issues.map(iss => ({\n ...iss,\n path: iss.path ? [${k}, ...iss.path] : [${k}]\n })));\n }\n }\n \n if (${id}.value === undefined) {\n if (${k} in input) {\n newResult[${k}] = undefined;\n }\n } else {\n newResult[${k}] = ${id}.value;\n }\n \n `);\n } else {\n doc.write(`\n if (${id}.issues.length) {\n payload.issues = payload.issues.concat(${id}.issues.map(iss => ({\n ...iss,\n path: iss.path ? [${k}, ...iss.path] : [${k}]\n })));\n }\n \n if (${id}.value === undefined) {\n if (${k} in input) {\n newResult[${k}] = undefined;\n }\n } else {\n newResult[${k}] = ${id}.value;\n }\n \n `);\n }\n }\n doc.write(`payload.value = newResult;`);\n doc.write(`return payload;`);\n const fn = doc.compile();\n return (payload, ctx) => fn(shape, payload, ctx);\n };\n let fastpass;\n const isObject3 = isObject;\n const jit = !globalConfig.jitless;\n const allowsEval2 = allowsEval;\n const fastEnabled = jit && allowsEval2.value;\n const catchall = def.catchall;\n let value;\n inst._zod.parse = (payload, ctx) => {\n value ?? (value = _normalized.value);\n const input = payload.value;\n if (!isObject3(input)) {\n payload.issues.push({\n expected: \"object\",\n code: \"invalid_type\",\n input,\n inst\n });\n return payload;\n }\n if (jit && fastEnabled && ctx?.async === false && ctx.jitless !== true) {\n if (!fastpass)\n fastpass = generateFastpass(def.shape);\n payload = fastpass(payload, ctx);\n if (!catchall)\n return payload;\n return handleCatchall([], input, payload, ctx, value, inst);\n }\n return superParse(payload, ctx);\n };\n });\n function handleUnionResults(results, final, inst, ctx) {\n for (const result of results) {\n if (result.issues.length === 0) {\n final.value = result.value;\n return final;\n }\n }\n const nonaborted = results.filter((r) => !aborted(r));\n if (nonaborted.length === 1) {\n final.value = nonaborted[0].value;\n return nonaborted[0];\n }\n final.issues.push({\n code: \"invalid_union\",\n input: final.value,\n inst,\n errors: results.map((result) => result.issues.map((iss) => finalizeIssue(iss, ctx, config())))\n });\n return final;\n }\n var $ZodUnion = /* @__PURE__ */ $constructor(\"$ZodUnion\", (inst, def) => {\n $ZodType.init(inst, def);\n defineLazy(inst._zod, \"optin\", () => def.options.some((o) => o._zod.optin === \"optional\") ? \"optional\" : void 0);\n defineLazy(inst._zod, \"optout\", () => def.options.some((o) => o._zod.optout === \"optional\") ? \"optional\" : void 0);\n defineLazy(inst._zod, \"values\", () => {\n if (def.options.every((o) => o._zod.values)) {\n return new Set(def.options.flatMap((option) => Array.from(option._zod.values)));\n }\n return void 0;\n });\n defineLazy(inst._zod, \"pattern\", () => {\n if (def.options.every((o) => o._zod.pattern)) {\n const patterns = def.options.map((o) => o._zod.pattern);\n return new RegExp(`^(${patterns.map((p) => cleanRegex(p.source)).join(\"|\")})$`);\n }\n return void 0;\n });\n const single = def.options.length === 1;\n const first = def.options[0]._zod.run;\n inst._zod.parse = (payload, ctx) => {\n if (single) {\n return first(payload, ctx);\n }\n let async = false;\n const results = [];\n for (const option of def.options) {\n const result = option._zod.run({\n value: payload.value,\n issues: []\n }, ctx);\n if (result instanceof Promise) {\n results.push(result);\n async = true;\n } else {\n if (result.issues.length === 0)\n return result;\n results.push(result);\n }\n }\n if (!async)\n return handleUnionResults(results, payload, inst, ctx);\n return Promise.all(results).then((results2) => {\n return handleUnionResults(results2, payload, inst, ctx);\n });\n };\n });\n function handleExclusiveUnionResults(results, final, inst, ctx) {\n const successes = results.filter((r) => r.issues.length === 0);\n if (successes.length === 1) {\n final.value = successes[0].value;\n return final;\n }\n if (successes.length === 0) {\n final.issues.push({\n code: \"invalid_union\",\n input: final.value,\n inst,\n errors: results.map((result) => result.issues.map((iss) => finalizeIssue(iss, ctx, config())))\n });\n } else {\n final.issues.push({\n code: \"invalid_union\",\n input: final.value,\n inst,\n errors: [],\n inclusive: false\n });\n }\n return final;\n }\n var $ZodXor = /* @__PURE__ */ $constructor(\"$ZodXor\", (inst, def) => {\n $ZodUnion.init(inst, def);\n def.inclusive = false;\n const single = def.options.length === 1;\n const first = def.options[0]._zod.run;\n inst._zod.parse = (payload, ctx) => {\n if (single) {\n return first(payload, ctx);\n }\n let async = false;\n const results = [];\n for (const option of def.options) {\n const result = option._zod.run({\n value: payload.value,\n issues: []\n }, ctx);\n if (result instanceof Promise) {\n results.push(result);\n async = true;\n } else {\n results.push(result);\n }\n }\n if (!async)\n return handleExclusiveUnionResults(results, payload, inst, ctx);\n return Promise.all(results).then((results2) => {\n return handleExclusiveUnionResults(results2, payload, inst, ctx);\n });\n };\n });\n var $ZodDiscriminatedUnion = /* @__PURE__ */ $constructor(\"$ZodDiscriminatedUnion\", (inst, def) => {\n def.inclusive = false;\n $ZodUnion.init(inst, def);\n const _super = inst._zod.parse;\n defineLazy(inst._zod, \"propValues\", () => {\n const propValues = {};\n for (const option of def.options) {\n const pv = option._zod.propValues;\n if (!pv || Object.keys(pv).length === 0)\n throw new Error(`Invalid discriminated union option at index \"${def.options.indexOf(option)}\"`);\n for (const [k, v] of Object.entries(pv)) {\n if (!propValues[k])\n propValues[k] = /* @__PURE__ */ new Set();\n for (const val of v) {\n propValues[k].add(val);\n }\n }\n }\n return propValues;\n });\n const disc = cached(() => {\n const opts = def.options;\n const map2 = /* @__PURE__ */ new Map();\n for (const o of opts) {\n const values = o._zod.propValues?.[def.discriminator];\n if (!values || values.size === 0)\n throw new Error(`Invalid discriminated union option at index \"${def.options.indexOf(o)}\"`);\n for (const v of values) {\n if (map2.has(v)) {\n throw new Error(`Duplicate discriminator value \"${String(v)}\"`);\n }\n map2.set(v, o);\n }\n }\n return map2;\n });\n inst._zod.parse = (payload, ctx) => {\n const input = payload.value;\n if (!isObject(input)) {\n payload.issues.push({\n code: \"invalid_type\",\n expected: \"object\",\n input,\n inst\n });\n return payload;\n }\n const opt = disc.value.get(input?.[def.discriminator]);\n if (opt) {\n return opt._zod.run(payload, ctx);\n }\n if (def.unionFallback) {\n return _super(payload, ctx);\n }\n payload.issues.push({\n code: \"invalid_union\",\n errors: [],\n note: \"No matching discriminator\",\n discriminator: def.discriminator,\n input,\n path: [def.discriminator],\n inst\n });\n return payload;\n };\n });\n var $ZodIntersection = /* @__PURE__ */ $constructor(\"$ZodIntersection\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.parse = (payload, ctx) => {\n const input = payload.value;\n const left = def.left._zod.run({ value: input, issues: [] }, ctx);\n const right = def.right._zod.run({ value: input, issues: [] }, ctx);\n const async = left instanceof Promise || right instanceof Promise;\n if (async) {\n return Promise.all([left, right]).then(([left2, right2]) => {\n return handleIntersectionResults(payload, left2, right2);\n });\n }\n return handleIntersectionResults(payload, left, right);\n };\n });\n function mergeValues(a, b) {\n if (a === b) {\n return { valid: true, data: a };\n }\n if (a instanceof Date && b instanceof Date && +a === +b) {\n return { valid: true, data: a };\n }\n if (isPlainObject(a) && isPlainObject(b)) {\n const bKeys = Object.keys(b);\n const sharedKeys = Object.keys(a).filter((key) => bKeys.indexOf(key) !== -1);\n const newObj = { ...a, ...b };\n for (const key of sharedKeys) {\n const sharedValue = mergeValues(a[key], b[key]);\n if (!sharedValue.valid) {\n return {\n valid: false,\n mergeErrorPath: [key, ...sharedValue.mergeErrorPath]\n };\n }\n newObj[key] = sharedValue.data;\n }\n return { valid: true, data: newObj };\n }\n if (Array.isArray(a) && Array.isArray(b)) {\n if (a.length !== b.length) {\n return { valid: false, mergeErrorPath: [] };\n }\n const newArray = [];\n for (let index = 0; index < a.length; index++) {\n const itemA = a[index];\n const itemB = b[index];\n const sharedValue = mergeValues(itemA, itemB);\n if (!sharedValue.valid) {\n return {\n valid: false,\n mergeErrorPath: [index, ...sharedValue.mergeErrorPath]\n };\n }\n newArray.push(sharedValue.data);\n }\n return { valid: true, data: newArray };\n }\n return { valid: false, mergeErrorPath: [] };\n }\n function handleIntersectionResults(result, left, right) {\n const unrecKeys = /* @__PURE__ */ new Map();\n let unrecIssue;\n for (const iss of left.issues) {\n if (iss.code === \"unrecognized_keys\") {\n unrecIssue ?? (unrecIssue = iss);\n for (const k of iss.keys) {\n if (!unrecKeys.has(k))\n unrecKeys.set(k, {});\n unrecKeys.get(k).l = true;\n }\n } else {\n result.issues.push(iss);\n }\n }\n for (const iss of right.issues) {\n if (iss.code === \"unrecognized_keys\") {\n for (const k of iss.keys) {\n if (!unrecKeys.has(k))\n unrecKeys.set(k, {});\n unrecKeys.get(k).r = true;\n }\n } else {\n result.issues.push(iss);\n }\n }\n const bothKeys = [...unrecKeys].filter(([, f]) => f.l && f.r).map(([k]) => k);\n if (bothKeys.length && unrecIssue) {\n result.issues.push({ ...unrecIssue, keys: bothKeys });\n }\n if (aborted(result))\n return result;\n const merged = mergeValues(left.value, right.value);\n if (!merged.valid) {\n throw new Error(`Unmergable intersection. Error path: ${JSON.stringify(merged.mergeErrorPath)}`);\n }\n result.value = merged.data;\n return result;\n }\n var $ZodTuple = /* @__PURE__ */ $constructor(\"$ZodTuple\", (inst, def) => {\n $ZodType.init(inst, def);\n const items = def.items;\n inst._zod.parse = (payload, ctx) => {\n const input = payload.value;\n if (!Array.isArray(input)) {\n payload.issues.push({\n input,\n inst,\n expected: \"tuple\",\n code: \"invalid_type\"\n });\n return payload;\n }\n payload.value = [];\n const proms = [];\n const reversedIndex = [...items].reverse().findIndex((item) => item._zod.optin !== \"optional\");\n const optStart = reversedIndex === -1 ? 0 : items.length - reversedIndex;\n if (!def.rest) {\n const tooBig = input.length > items.length;\n const tooSmall = input.length < optStart - 1;\n if (tooBig || tooSmall) {\n payload.issues.push({\n ...tooBig ? { code: \"too_big\", maximum: items.length, inclusive: true } : { code: \"too_small\", minimum: items.length },\n input,\n inst,\n origin: \"array\"\n });\n return payload;\n }\n }\n let i = -1;\n for (const item of items) {\n i++;\n if (i >= input.length) {\n if (i >= optStart)\n continue;\n }\n const result = item._zod.run({\n value: input[i],\n issues: []\n }, ctx);\n if (result instanceof Promise) {\n proms.push(result.then((result2) => handleTupleResult(result2, payload, i)));\n } else {\n handleTupleResult(result, payload, i);\n }\n }\n if (def.rest) {\n const rest = input.slice(items.length);\n for (const el of rest) {\n i++;\n const result = def.rest._zod.run({\n value: el,\n issues: []\n }, ctx);\n if (result instanceof Promise) {\n proms.push(result.then((result2) => handleTupleResult(result2, payload, i)));\n } else {\n handleTupleResult(result, payload, i);\n }\n }\n }\n if (proms.length)\n return Promise.all(proms).then(() => payload);\n return payload;\n };\n });\n function handleTupleResult(result, final, index) {\n if (result.issues.length) {\n final.issues.push(...prefixIssues(index, result.issues));\n }\n final.value[index] = result.value;\n }\n var $ZodRecord = /* @__PURE__ */ $constructor(\"$ZodRecord\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.parse = (payload, ctx) => {\n const input = payload.value;\n if (!isPlainObject(input)) {\n payload.issues.push({\n expected: \"record\",\n code: \"invalid_type\",\n input,\n inst\n });\n return payload;\n }\n const proms = [];\n const values = def.keyType._zod.values;\n if (values) {\n payload.value = {};\n const recordKeys = /* @__PURE__ */ new Set();\n for (const key of values) {\n if (typeof key === \"string\" || typeof key === \"number\" || typeof key === \"symbol\") {\n recordKeys.add(typeof key === \"number\" ? key.toString() : key);\n const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);\n if (result instanceof Promise) {\n proms.push(result.then((result2) => {\n if (result2.issues.length) {\n payload.issues.push(...prefixIssues(key, result2.issues));\n }\n payload.value[key] = result2.value;\n }));\n } else {\n if (result.issues.length) {\n payload.issues.push(...prefixIssues(key, result.issues));\n }\n payload.value[key] = result.value;\n }\n }\n }\n let unrecognized;\n for (const key in input) {\n if (!recordKeys.has(key)) {\n unrecognized = unrecognized ?? [];\n unrecognized.push(key);\n }\n }\n if (unrecognized && unrecognized.length > 0) {\n payload.issues.push({\n code: \"unrecognized_keys\",\n input,\n inst,\n keys: unrecognized\n });\n }\n } else {\n payload.value = {};\n for (const key of Reflect.ownKeys(input)) {\n if (key === \"__proto__\")\n continue;\n let keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);\n if (keyResult instanceof Promise) {\n throw new Error(\"Async schemas not supported in object keys currently\");\n }\n const checkNumericKey = typeof key === \"string\" && number.test(key) && keyResult.issues.length;\n if (checkNumericKey) {\n const retryResult = def.keyType._zod.run({ value: Number(key), issues: [] }, ctx);\n if (retryResult instanceof Promise) {\n throw new Error(\"Async schemas not supported in object keys currently\");\n }\n if (retryResult.issues.length === 0) {\n keyResult = retryResult;\n }\n }\n if (keyResult.issues.length) {\n if (def.mode === \"loose\") {\n payload.value[key] = input[key];\n } else {\n payload.issues.push({\n code: \"invalid_key\",\n origin: \"record\",\n issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),\n input: key,\n path: [key],\n inst\n });\n }\n continue;\n }\n const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);\n if (result instanceof Promise) {\n proms.push(result.then((result2) => {\n if (result2.issues.length) {\n payload.issues.push(...prefixIssues(key, result2.issues));\n }\n payload.value[keyResult.value] = result2.value;\n }));\n } else {\n if (result.issues.length) {\n payload.issues.push(...prefixIssues(key, result.issues));\n }\n payload.value[keyResult.value] = result.value;\n }\n }\n }\n if (proms.length) {\n return Promise.all(proms).then(() => payload);\n }\n return payload;\n };\n });\n var $ZodMap = /* @__PURE__ */ $constructor(\"$ZodMap\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.parse = (payload, ctx) => {\n const input = payload.value;\n if (!(input instanceof Map)) {\n payload.issues.push({\n expected: \"map\",\n code: \"invalid_type\",\n input,\n inst\n });\n return payload;\n }\n const proms = [];\n payload.value = /* @__PURE__ */ new Map();\n for (const [key, value] of input) {\n const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);\n const valueResult = def.valueType._zod.run({ value, issues: [] }, ctx);\n if (keyResult instanceof Promise || valueResult instanceof Promise) {\n proms.push(Promise.all([keyResult, valueResult]).then(([keyResult2, valueResult2]) => {\n handleMapResult(keyResult2, valueResult2, payload, key, input, inst, ctx);\n }));\n } else {\n handleMapResult(keyResult, valueResult, payload, key, input, inst, ctx);\n }\n }\n if (proms.length)\n return Promise.all(proms).then(() => payload);\n return payload;\n };\n });\n function handleMapResult(keyResult, valueResult, final, key, input, inst, ctx) {\n if (keyResult.issues.length) {\n if (propertyKeyTypes.has(typeof key)) {\n final.issues.push(...prefixIssues(key, keyResult.issues));\n } else {\n final.issues.push({\n code: \"invalid_key\",\n origin: \"map\",\n input,\n inst,\n issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config()))\n });\n }\n }\n if (valueResult.issues.length) {\n if (propertyKeyTypes.has(typeof key)) {\n final.issues.push(...prefixIssues(key, valueResult.issues));\n } else {\n final.issues.push({\n origin: \"map\",\n code: \"invalid_element\",\n input,\n inst,\n key,\n issues: valueResult.issues.map((iss) => finalizeIssue(iss, ctx, config()))\n });\n }\n }\n final.value.set(keyResult.value, valueResult.value);\n }\n var $ZodSet = /* @__PURE__ */ $constructor(\"$ZodSet\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.parse = (payload, ctx) => {\n const input = payload.value;\n if (!(input instanceof Set)) {\n payload.issues.push({\n input,\n inst,\n expected: \"set\",\n code: \"invalid_type\"\n });\n return payload;\n }\n const proms = [];\n payload.value = /* @__PURE__ */ new Set();\n for (const item of input) {\n const result = def.valueType._zod.run({ value: item, issues: [] }, ctx);\n if (result instanceof Promise) {\n proms.push(result.then((result2) => handleSetResult(result2, payload)));\n } else\n handleSetResult(result, payload);\n }\n if (proms.length)\n return Promise.all(proms).then(() => payload);\n return payload;\n };\n });\n function handleSetResult(result, final) {\n if (result.issues.length) {\n final.issues.push(...result.issues);\n }\n final.value.add(result.value);\n }\n var $ZodEnum = /* @__PURE__ */ $constructor(\"$ZodEnum\", (inst, def) => {\n $ZodType.init(inst, def);\n const values = getEnumValues(def.entries);\n const valuesSet = new Set(values);\n inst._zod.values = valuesSet;\n inst._zod.pattern = new RegExp(`^(${values.filter((k) => propertyKeyTypes.has(typeof k)).map((o) => typeof o === \"string\" ? escapeRegex(o) : o.toString()).join(\"|\")})$`);\n inst._zod.parse = (payload, _ctx) => {\n const input = payload.value;\n if (valuesSet.has(input)) {\n return payload;\n }\n payload.issues.push({\n code: \"invalid_value\",\n values,\n input,\n inst\n });\n return payload;\n };\n });\n var $ZodLiteral = /* @__PURE__ */ $constructor(\"$ZodLiteral\", (inst, def) => {\n $ZodType.init(inst, def);\n if (def.values.length === 0) {\n throw new Error(\"Cannot create literal schema with no valid values\");\n }\n const values = new Set(def.values);\n inst._zod.values = values;\n inst._zod.pattern = new RegExp(`^(${def.values.map((o) => typeof o === \"string\" ? escapeRegex(o) : o ? escapeRegex(o.toString()) : String(o)).join(\"|\")})$`);\n inst._zod.parse = (payload, _ctx) => {\n const input = payload.value;\n if (values.has(input)) {\n return payload;\n }\n payload.issues.push({\n code: \"invalid_value\",\n values: def.values,\n input,\n inst\n });\n return payload;\n };\n });\n var $ZodFile = /* @__PURE__ */ $constructor(\"$ZodFile\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.parse = (payload, _ctx) => {\n const input = payload.value;\n if (input instanceof File)\n return payload;\n payload.issues.push({\n expected: \"file\",\n code: \"invalid_type\",\n input,\n inst\n });\n return payload;\n };\n });\n var $ZodTransform = /* @__PURE__ */ $constructor(\"$ZodTransform\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.parse = (payload, ctx) => {\n if (ctx.direction === \"backward\") {\n throw new $ZodEncodeError(inst.constructor.name);\n }\n const _out = def.transform(payload.value, payload);\n if (ctx.async) {\n const output = _out instanceof Promise ? _out : Promise.resolve(_out);\n return output.then((output2) => {\n payload.value = output2;\n return payload;\n });\n }\n if (_out instanceof Promise) {\n throw new $ZodAsyncError();\n }\n payload.value = _out;\n return payload;\n };\n });\n function handleOptionalResult(result, input) {\n if (result.issues.length && input === void 0) {\n return { issues: [], value: void 0 };\n }\n return result;\n }\n var $ZodOptional = /* @__PURE__ */ $constructor(\"$ZodOptional\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.optin = \"optional\";\n inst._zod.optout = \"optional\";\n defineLazy(inst._zod, \"values\", () => {\n return def.innerType._zod.values ? /* @__PURE__ */ new Set([...def.innerType._zod.values, void 0]) : void 0;\n });\n defineLazy(inst._zod, \"pattern\", () => {\n const pattern = def.innerType._zod.pattern;\n return pattern ? new RegExp(`^(${cleanRegex(pattern.source)})?$`) : void 0;\n });\n inst._zod.parse = (payload, ctx) => {\n if (def.innerType._zod.optin === \"optional\") {\n const result = def.innerType._zod.run(payload, ctx);\n if (result instanceof Promise)\n return result.then((r) => handleOptionalResult(r, payload.value));\n return handleOptionalResult(result, payload.value);\n }\n if (payload.value === void 0) {\n return payload;\n }\n return def.innerType._zod.run(payload, ctx);\n };\n });\n var $ZodExactOptional = /* @__PURE__ */ $constructor(\"$ZodExactOptional\", (inst, def) => {\n $ZodOptional.init(inst, def);\n defineLazy(inst._zod, \"values\", () => def.innerType._zod.values);\n defineLazy(inst._zod, \"pattern\", () => def.innerType._zod.pattern);\n inst._zod.parse = (payload, ctx) => {\n return def.innerType._zod.run(payload, ctx);\n };\n });\n var $ZodNullable = /* @__PURE__ */ $constructor(\"$ZodNullable\", (inst, def) => {\n $ZodType.init(inst, def);\n defineLazy(inst._zod, \"optin\", () => def.innerType._zod.optin);\n defineLazy(inst._zod, \"optout\", () => def.innerType._zod.optout);\n defineLazy(inst._zod, \"pattern\", () => {\n const pattern = def.innerType._zod.pattern;\n return pattern ? new RegExp(`^(${cleanRegex(pattern.source)}|null)$`) : void 0;\n });\n defineLazy(inst._zod, \"values\", () => {\n return def.innerType._zod.values ? /* @__PURE__ */ new Set([...def.innerType._zod.values, null]) : void 0;\n });\n inst._zod.parse = (payload, ctx) => {\n if (payload.value === null)\n return payload;\n return def.innerType._zod.run(payload, ctx);\n };\n });\n var $ZodDefault = /* @__PURE__ */ $constructor(\"$ZodDefault\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.optin = \"optional\";\n defineLazy(inst._zod, \"values\", () => def.innerType._zod.values);\n inst._zod.parse = (payload, ctx) => {\n if (ctx.direction === \"backward\") {\n return def.innerType._zod.run(payload, ctx);\n }\n if (payload.value === void 0) {\n payload.value = def.defaultValue;\n return payload;\n }\n const result = def.innerType._zod.run(payload, ctx);\n if (result instanceof Promise) {\n return result.then((result2) => handleDefaultResult(result2, def));\n }\n return handleDefaultResult(result, def);\n };\n });\n function handleDefaultResult(payload, def) {\n if (payload.value === void 0) {\n payload.value = def.defaultValue;\n }\n return payload;\n }\n var $ZodPrefault = /* @__PURE__ */ $constructor(\"$ZodPrefault\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.optin = \"optional\";\n defineLazy(inst._zod, \"values\", () => def.innerType._zod.values);\n inst._zod.parse = (payload, ctx) => {\n if (ctx.direction === \"backward\") {\n return def.innerType._zod.run(payload, ctx);\n }\n if (payload.value === void 0) {\n payload.value = def.defaultValue;\n }\n return def.innerType._zod.run(payload, ctx);\n };\n });\n var $ZodNonOptional = /* @__PURE__ */ $constructor(\"$ZodNonOptional\", (inst, def) => {\n $ZodType.init(inst, def);\n defineLazy(inst._zod, \"values\", () => {\n const v = def.innerType._zod.values;\n return v ? new Set([...v].filter((x) => x !== void 0)) : void 0;\n });\n inst._zod.parse = (payload, ctx) => {\n const result = def.innerType._zod.run(payload, ctx);\n if (result instanceof Promise) {\n return result.then((result2) => handleNonOptionalResult(result2, inst));\n }\n return handleNonOptionalResult(result, inst);\n };\n });\n function handleNonOptionalResult(payload, inst) {\n if (!payload.issues.length && payload.value === void 0) {\n payload.issues.push({\n code: \"invalid_type\",\n expected: \"nonoptional\",\n input: payload.value,\n inst\n });\n }\n return payload;\n }\n var $ZodSuccess = /* @__PURE__ */ $constructor(\"$ZodSuccess\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.parse = (payload, ctx) => {\n if (ctx.direction === \"backward\") {\n throw new $ZodEncodeError(\"ZodSuccess\");\n }\n const result = def.innerType._zod.run(payload, ctx);\n if (result instanceof Promise) {\n return result.then((result2) => {\n payload.value = result2.issues.length === 0;\n return payload;\n });\n }\n payload.value = result.issues.length === 0;\n return payload;\n };\n });\n var $ZodCatch = /* @__PURE__ */ $constructor(\"$ZodCatch\", (inst, def) => {\n $ZodType.init(inst, def);\n defineLazy(inst._zod, \"optin\", () => def.innerType._zod.optin);\n defineLazy(inst._zod, \"optout\", () => def.innerType._zod.optout);\n defineLazy(inst._zod, \"values\", () => def.innerType._zod.values);\n inst._zod.parse = (payload, ctx) => {\n if (ctx.direction === \"backward\") {\n return def.innerType._zod.run(payload, ctx);\n }\n const result = def.innerType._zod.run(payload, ctx);\n if (result instanceof Promise) {\n return result.then((result2) => {\n payload.value = result2.value;\n if (result2.issues.length) {\n payload.value = def.catchValue({\n ...payload,\n error: {\n issues: result2.issues.map((iss) => finalizeIssue(iss, ctx, config()))\n },\n input: payload.value\n });\n payload.issues = [];\n }\n return payload;\n });\n }\n payload.value = result.value;\n if (result.issues.length) {\n payload.value = def.catchValue({\n ...payload,\n error: {\n issues: result.issues.map((iss) => finalizeIssue(iss, ctx, config()))\n },\n input: payload.value\n });\n payload.issues = [];\n }\n return payload;\n };\n });\n var $ZodNaN = /* @__PURE__ */ $constructor(\"$ZodNaN\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.parse = (payload, _ctx) => {\n if (typeof payload.value !== \"number\" || !Number.isNaN(payload.value)) {\n payload.issues.push({\n input: payload.value,\n inst,\n expected: \"nan\",\n code: \"invalid_type\"\n });\n return payload;\n }\n return payload;\n };\n });\n var $ZodPipe = /* @__PURE__ */ $constructor(\"$ZodPipe\", (inst, def) => {\n $ZodType.init(inst, def);\n defineLazy(inst._zod, \"values\", () => def.in._zod.values);\n defineLazy(inst._zod, \"optin\", () => def.in._zod.optin);\n defineLazy(inst._zod, \"optout\", () => def.out._zod.optout);\n defineLazy(inst._zod, \"propValues\", () => def.in._zod.propValues);\n inst._zod.parse = (payload, ctx) => {\n if (ctx.direction === \"backward\") {\n const right = def.out._zod.run(payload, ctx);\n if (right instanceof Promise) {\n return right.then((right2) => handlePipeResult(right2, def.in, ctx));\n }\n return handlePipeResult(right, def.in, ctx);\n }\n const left = def.in._zod.run(payload, ctx);\n if (left instanceof Promise) {\n return left.then((left2) => handlePipeResult(left2, def.out, ctx));\n }\n return handlePipeResult(left, def.out, ctx);\n };\n });\n function handlePipeResult(left, next, ctx) {\n if (left.issues.length) {\n left.aborted = true;\n return left;\n }\n return next._zod.run({ value: left.value, issues: left.issues }, ctx);\n }\n var $ZodCodec = /* @__PURE__ */ $constructor(\"$ZodCodec\", (inst, def) => {\n $ZodType.init(inst, def);\n defineLazy(inst._zod, \"values\", () => def.in._zod.values);\n defineLazy(inst._zod, \"optin\", () => def.in._zod.optin);\n defineLazy(inst._zod, \"optout\", () => def.out._zod.optout);\n defineLazy(inst._zod, \"propValues\", () => def.in._zod.propValues);\n inst._zod.parse = (payload, ctx) => {\n const direction = ctx.direction || \"forward\";\n if (direction === \"forward\") {\n const left = def.in._zod.run(payload, ctx);\n if (left instanceof Promise) {\n return left.then((left2) => handleCodecAResult(left2, def, ctx));\n }\n return handleCodecAResult(left, def, ctx);\n } else {\n const right = def.out._zod.run(payload, ctx);\n if (right instanceof Promise) {\n return right.then((right2) => handleCodecAResult(right2, def, ctx));\n }\n return handleCodecAResult(right, def, ctx);\n }\n };\n });\n function handleCodecAResult(result, def, ctx) {\n if (result.issues.length) {\n result.aborted = true;\n return result;\n }\n const direction = ctx.direction || \"forward\";\n if (direction === \"forward\") {\n const transformed = def.transform(result.value, result);\n if (transformed instanceof Promise) {\n return transformed.then((value) => handleCodecTxResult(result, value, def.out, ctx));\n }\n return handleCodecTxResult(result, transformed, def.out, ctx);\n } else {\n const transformed = def.reverseTransform(result.value, result);\n if (transformed instanceof Promise) {\n return transformed.then((value) => handleCodecTxResult(result, value, def.in, ctx));\n }\n return handleCodecTxResult(result, transformed, def.in, ctx);\n }\n }\n function handleCodecTxResult(left, value, nextSchema, ctx) {\n if (left.issues.length) {\n left.aborted = true;\n return left;\n }\n return nextSchema._zod.run({ value, issues: left.issues }, ctx);\n }\n var $ZodReadonly = /* @__PURE__ */ $constructor(\"$ZodReadonly\", (inst, def) => {\n $ZodType.init(inst, def);\n defineLazy(inst._zod, \"propValues\", () => def.innerType._zod.propValues);\n defineLazy(inst._zod, \"values\", () => def.innerType._zod.values);\n defineLazy(inst._zod, \"optin\", () => def.innerType?._zod?.optin);\n defineLazy(inst._zod, \"optout\", () => def.innerType?._zod?.optout);\n inst._zod.parse = (payload, ctx) => {\n if (ctx.direction === \"backward\") {\n return def.innerType._zod.run(payload, ctx);\n }\n const result = def.innerType._zod.run(payload, ctx);\n if (result instanceof Promise) {\n return result.then(handleReadonlyResult);\n }\n return handleReadonlyResult(result);\n };\n });\n function handleReadonlyResult(payload) {\n payload.value = Object.freeze(payload.value);\n return payload;\n }\n var $ZodTemplateLiteral = /* @__PURE__ */ $constructor(\"$ZodTemplateLiteral\", (inst, def) => {\n $ZodType.init(inst, def);\n const regexParts = [];\n for (const part of def.parts) {\n if (typeof part === \"object\" && part !== null) {\n if (!part._zod.pattern) {\n throw new Error(`Invalid template literal part, no pattern found: ${[...part._zod.traits].shift()}`);\n }\n const source = part._zod.pattern instanceof RegExp ? part._zod.pattern.source : part._zod.pattern;\n if (!source)\n throw new Error(`Invalid template literal part: ${part._zod.traits}`);\n const start = source.startsWith(\"^\") ? 1 : 0;\n const end = source.endsWith(\"$\") ? source.length - 1 : source.length;\n regexParts.push(source.slice(start, end));\n } else if (part === null || primitiveTypes.has(typeof part)) {\n regexParts.push(escapeRegex(`${part}`));\n } else {\n throw new Error(`Invalid template literal part: ${part}`);\n }\n }\n inst._zod.pattern = new RegExp(`^${regexParts.join(\"\")}$`);\n inst._zod.parse = (payload, _ctx) => {\n if (typeof payload.value !== \"string\") {\n payload.issues.push({\n input: payload.value,\n inst,\n expected: \"string\",\n code: \"invalid_type\"\n });\n return payload;\n }\n inst._zod.pattern.lastIndex = 0;\n if (!inst._zod.pattern.test(payload.value)) {\n payload.issues.push({\n input: payload.value,\n inst,\n code: \"invalid_format\",\n format: def.format ?? \"template_literal\",\n pattern: inst._zod.pattern.source\n });\n return payload;\n }\n return payload;\n };\n });\n var $ZodFunction = /* @__PURE__ */ $constructor(\"$ZodFunction\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._def = def;\n inst._zod.def = def;\n inst.implement = (func) => {\n if (typeof func !== \"function\") {\n throw new Error(\"implement() must be called with a function\");\n }\n return function(...args) {\n const parsedArgs = inst._def.input ? parse(inst._def.input, args) : args;\n const result = Reflect.apply(func, this, parsedArgs);\n if (inst._def.output) {\n return parse(inst._def.output, result);\n }\n return result;\n };\n };\n inst.implementAsync = (func) => {\n if (typeof func !== \"function\") {\n throw new Error(\"implementAsync() must be called with a function\");\n }\n return async function(...args) {\n const parsedArgs = inst._def.input ? await parseAsync(inst._def.input, args) : args;\n const result = await Reflect.apply(func, this, parsedArgs);\n if (inst._def.output) {\n return await parseAsync(inst._def.output, result);\n }\n return result;\n };\n };\n inst._zod.parse = (payload, _ctx) => {\n if (typeof payload.value !== \"function\") {\n payload.issues.push({\n code: \"invalid_type\",\n expected: \"function\",\n input: payload.value,\n inst\n });\n return payload;\n }\n const hasPromiseOutput = inst._def.output && inst._def.output._zod.def.type === \"promise\";\n if (hasPromiseOutput) {\n payload.value = inst.implementAsync(payload.value);\n } else {\n payload.value = inst.implement(payload.value);\n }\n return payload;\n };\n inst.input = (...args) => {\n const F = inst.constructor;\n if (Array.isArray(args[0])) {\n return new F({\n type: \"function\",\n input: new $ZodTuple({\n type: \"tuple\",\n items: args[0],\n rest: args[1]\n }),\n output: inst._def.output\n });\n }\n return new F({\n type: \"function\",\n input: args[0],\n output: inst._def.output\n });\n };\n inst.output = (output) => {\n const F = inst.constructor;\n return new F({\n type: \"function\",\n input: inst._def.input,\n output\n });\n };\n return inst;\n });\n var $ZodPromise = /* @__PURE__ */ $constructor(\"$ZodPromise\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.parse = (payload, ctx) => {\n return Promise.resolve(payload.value).then((inner) => def.innerType._zod.run({ value: inner, issues: [] }, ctx));\n };\n });\n var $ZodLazy = /* @__PURE__ */ $constructor(\"$ZodLazy\", (inst, def) => {\n $ZodType.init(inst, def);\n defineLazy(inst._zod, \"innerType\", () => def.getter());\n defineLazy(inst._zod, \"pattern\", () => inst._zod.innerType?._zod?.pattern);\n defineLazy(inst._zod, \"propValues\", () => inst._zod.innerType?._zod?.propValues);\n defineLazy(inst._zod, \"optin\", () => inst._zod.innerType?._zod?.optin ?? void 0);\n defineLazy(inst._zod, \"optout\", () => inst._zod.innerType?._zod?.optout ?? void 0);\n inst._zod.parse = (payload, ctx) => {\n const inner = inst._zod.innerType;\n return inner._zod.run(payload, ctx);\n };\n });\n var $ZodCustom = /* @__PURE__ */ $constructor(\"$ZodCustom\", (inst, def) => {\n $ZodCheck.init(inst, def);\n $ZodType.init(inst, def);\n inst._zod.parse = (payload, _) => {\n return payload;\n };\n inst._zod.check = (payload) => {\n const input = payload.value;\n const r = def.fn(input);\n if (r instanceof Promise) {\n return r.then((r2) => handleRefineResult(r2, payload, input, inst));\n }\n handleRefineResult(r, payload, input, inst);\n return;\n };\n });\n function handleRefineResult(result, payload, input, inst) {\n if (!result) {\n const _iss = {\n code: \"custom\",\n input,\n inst,\n // incorporates params.error into issue reporting\n path: [...inst._zod.def.path ?? []],\n // incorporates params.error into issue reporting\n continue: !inst._zod.def.abort\n // params: inst._zod.def.params,\n };\n if (inst._zod.def.params)\n _iss.params = inst._zod.def.params;\n payload.issues.push(issue(_iss));\n }\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/index.js\n var locales_exports = {};\n __export(locales_exports, {\n ar: () => ar_default,\n az: () => az_default,\n be: () => be_default,\n bg: () => bg_default,\n ca: () => ca_default,\n cs: () => cs_default,\n da: () => da_default,\n de: () => de_default,\n en: () => en_default,\n eo: () => eo_default,\n es: () => es_default,\n fa: () => fa_default,\n fi: () => fi_default,\n fr: () => fr_default,\n frCA: () => fr_CA_default,\n he: () => he_default,\n hu: () => hu_default,\n hy: () => hy_default,\n id: () => id_default,\n is: () => is_default,\n it: () => it_default,\n ja: () => ja_default,\n ka: () => ka_default,\n kh: () => kh_default,\n km: () => km_default,\n ko: () => ko_default,\n lt: () => lt_default,\n mk: () => mk_default,\n ms: () => ms_default,\n nl: () => nl_default,\n no: () => no_default,\n ota: () => ota_default,\n pl: () => pl_default,\n ps: () => ps_default,\n pt: () => pt_default,\n ru: () => ru_default,\n sl: () => sl_default,\n sv: () => sv_default,\n ta: () => ta_default,\n th: () => th_default,\n tr: () => tr_default,\n ua: () => ua_default,\n uk: () => uk_default,\n ur: () => ur_default,\n uz: () => uz_default,\n vi: () => vi_default,\n yo: () => yo_default,\n zhCN: () => zh_CN_default,\n zhTW: () => zh_TW_default\n });\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/ar.js\n var error = () => {\n const Sizable = {\n string: { unit: \"\\u062D\\u0631\\u0641\", verb: \"\\u0623\\u0646 \\u064A\\u062D\\u0648\\u064A\" },\n file: { unit: \"\\u0628\\u0627\\u064A\\u062A\", verb: \"\\u0623\\u0646 \\u064A\\u062D\\u0648\\u064A\" },\n array: { unit: \"\\u0639\\u0646\\u0635\\u0631\", verb: \"\\u0623\\u0646 \\u064A\\u062D\\u0648\\u064A\" },\n set: { unit: \"\\u0639\\u0646\\u0635\\u0631\", verb: \"\\u0623\\u0646 \\u064A\\u062D\\u0648\\u064A\" }\n };\n function getSizing(origin) {\n return Sizable[origin] ?? null;\n }\n const FormatDictionary = {\n regex: \"\\u0645\\u062F\\u062E\\u0644\",\n email: \"\\u0628\\u0631\\u064A\\u062F \\u0625\\u0644\\u0643\\u062A\\u0631\\u0648\\u0646\\u064A\",\n url: \"\\u0631\\u0627\\u0628\\u0637\",\n emoji: \"\\u0625\\u064A\\u0645\\u0648\\u062C\\u064A\",\n uuid: \"UUID\",\n uuidv4: \"UUIDv4\",\n uuidv6: \"UUIDv6\",\n nanoid: \"nanoid\",\n guid: \"GUID\",\n cuid: \"cuid\",\n cuid2: \"cuid2\",\n ulid: \"ULID\",\n xid: \"XID\",\n ksuid: \"KSUID\",\n datetime: \"\\u062A\\u0627\\u0631\\u064A\\u062E \\u0648\\u0648\\u0642\\u062A \\u0628\\u0645\\u0639\\u064A\\u0627\\u0631 ISO\",\n date: \"\\u062A\\u0627\\u0631\\u064A\\u062E \\u0628\\u0645\\u0639\\u064A\\u0627\\u0631 ISO\",\n time: \"\\u0648\\u0642\\u062A \\u0628\\u0645\\u0639\\u064A\\u0627\\u0631 ISO\",\n duration: \"\\u0645\\u062F\\u0629 \\u0628\\u0645\\u0639\\u064A\\u0627\\u0631 ISO\",\n ipv4: \"\\u0639\\u0646\\u0648\\u0627\\u0646 IPv4\",\n ipv6: \"\\u0639\\u0646\\u0648\\u0627\\u0646 IPv6\",\n cidrv4: \"\\u0645\\u062F\\u0649 \\u0639\\u0646\\u0627\\u0648\\u064A\\u0646 \\u0628\\u0635\\u064A\\u063A\\u0629 IPv4\",\n cidrv6: \"\\u0645\\u062F\\u0649 \\u0639\\u0646\\u0627\\u0648\\u064A\\u0646 \\u0628\\u0635\\u064A\\u063A\\u0629 IPv6\",\n base64: \"\\u0646\\u064E\\u0635 \\u0628\\u062A\\u0631\\u0645\\u064A\\u0632 base64-encoded\",\n base64url: \"\\u0646\\u064E\\u0635 \\u0628\\u062A\\u0631\\u0645\\u064A\\u0632 base64url-encoded\",\n json_string: \"\\u0646\\u064E\\u0635 \\u0639\\u0644\\u0649 \\u0647\\u064A\\u0626\\u0629 JSON\",\n e164: \"\\u0631\\u0642\\u0645 \\u0647\\u0627\\u062A\\u0641 \\u0628\\u0645\\u0639\\u064A\\u0627\\u0631 E.164\",\n jwt: \"JWT\",\n template_literal: \"\\u0645\\u062F\\u062E\\u0644\"\n };\n const TypeDictionary = {\n nan: \"NaN\"\n };\n return (issue2) => {\n switch (issue2.code) {\n case \"invalid_type\": {\n const expected = TypeDictionary[issue2.expected] ?? issue2.expected;\n const receivedType = parsedType(issue2.input);\n const received = TypeDictionary[receivedType] ?? receivedType;\n if (/^[A-Z]/.test(issue2.expected)) {\n return `\\u0645\\u062F\\u062E\\u0644\\u0627\\u062A \\u063A\\u064A\\u0631 \\u0645\\u0642\\u0628\\u0648\\u0644\\u0629: \\u064A\\u0641\\u062A\\u0631\\u0636 \\u0625\\u062F\\u062E\\u0627\\u0644 instanceof ${issue2.expected}\\u060C \\u0648\\u0644\\u0643\\u0646 \\u062A\\u0645 \\u0625\\u062F\\u062E\\u0627\\u0644 ${received}`;\n }\n return `\\u0645\\u062F\\u062E\\u0644\\u0627\\u062A \\u063A\\u064A\\u0631 \\u0645\\u0642\\u0628\\u0648\\u0644\\u0629: \\u064A\\u0641\\u062A\\u0631\\u0636 \\u0625\\u062F\\u062E\\u0627\\u0644 ${expected}\\u060C \\u0648\\u0644\\u0643\\u0646 \\u062A\\u0645 \\u0625\\u062F\\u062E\\u0627\\u0644 ${received}`;\n }\n case \"invalid_value\":\n if (issue2.values.length === 1)\n return `\\u0645\\u062F\\u062E\\u0644\\u0627\\u062A \\u063A\\u064A\\u0631 \\u0645\\u0642\\u0628\\u0648\\u0644\\u0629: \\u064A\\u0641\\u062A\\u0631\\u0636 \\u0625\\u062F\\u062E\\u0627\\u0644 ${stringifyPrimitive(issue2.values[0])}`;\n return `\\u0627\\u062E\\u062A\\u064A\\u0627\\u0631 \\u063A\\u064A\\u0631 \\u0645\\u0642\\u0628\\u0648\\u0644: \\u064A\\u062A\\u0648\\u0642\\u0639 \\u0627\\u0646\\u062A\\u0642\\u0627\\u0621 \\u0623\\u062D\\u062F \\u0647\\u0630\\u0647 \\u0627\\u0644\\u062E\\u064A\\u0627\\u0631\\u0627\\u062A: ${joinValues(issue2.values, \"|\")}`;\n case \"too_big\": {\n const adj = issue2.inclusive ? \"<=\" : \"<\";\n const sizing = getSizing(issue2.origin);\n if (sizing)\n return ` \\u0623\\u0643\\u0628\\u0631 \\u0645\\u0646 \\u0627\\u0644\\u0644\\u0627\\u0632\\u0645: \\u064A\\u0641\\u062A\\u0631\\u0636 \\u0623\\u0646 \\u062A\\u0643\\u0648\\u0646 ${issue2.origin ?? \"\\u0627\\u0644\\u0642\\u064A\\u0645\\u0629\"} ${adj} ${issue2.maximum.toString()} ${sizing.unit ?? \"\\u0639\\u0646\\u0635\\u0631\"}`;\n return `\\u0623\\u0643\\u0628\\u0631 \\u0645\\u0646 \\u0627\\u0644\\u0644\\u0627\\u0632\\u0645: \\u064A\\u0641\\u062A\\u0631\\u0636 \\u0623\\u0646 \\u062A\\u0643\\u0648\\u0646 ${issue2.origin ?? \"\\u0627\\u0644\\u0642\\u064A\\u0645\\u0629\"} ${adj} ${issue2.maximum.toString()}`;\n }\n case \"too_small\": {\n const adj = issue2.inclusive ? \">=\" : \">\";\n const sizing = getSizing(issue2.origin);\n if (sizing) {\n return `\\u0623\\u0635\\u063A\\u0631 \\u0645\\u0646 \\u0627\\u0644\\u0644\\u0627\\u0632\\u0645: \\u064A\\u0641\\u062A\\u0631\\u0636 \\u0644\\u0640 ${issue2.origin} \\u0623\\u0646 \\u064A\\u0643\\u0648\\u0646 ${adj} ${issue2.minimum.toString()} ${sizing.unit}`;\n }\n return `\\u0623\\u0635\\u063A\\u0631 \\u0645\\u0646 \\u0627\\u0644\\u0644\\u0627\\u0632\\u0645: \\u064A\\u0641\\u062A\\u0631\\u0636 \\u0644\\u0640 ${issue2.origin} \\u0623\\u0646 \\u064A\\u0643\\u0648\\u0646 ${adj} ${issue2.minimum.toString()}`;\n }\n case \"invalid_format\": {\n const _issue = issue2;\n if (_issue.format === \"starts_with\")\n return `\\u0646\\u064E\\u0635 \\u063A\\u064A\\u0631 \\u0645\\u0642\\u0628\\u0648\\u0644: \\u064A\\u062C\\u0628 \\u0623\\u0646 \\u064A\\u0628\\u062F\\u0623 \\u0628\\u0640 \"${issue2.prefix}\"`;\n if (_issue.format === \"ends_with\")\n return `\\u0646\\u064E\\u0635 \\u063A\\u064A\\u0631 \\u0645\\u0642\\u0628\\u0648\\u0644: \\u064A\\u062C\\u0628 \\u0623\\u0646 \\u064A\\u0646\\u062A\\u0647\\u064A \\u0628\\u0640 \"${_issue.suffix}\"`;\n if (_issue.format === \"includes\")\n return `\\u0646\\u064E\\u0635 \\u063A\\u064A\\u0631 \\u0645\\u0642\\u0628\\u0648\\u0644: \\u064A\\u062C\\u0628 \\u0623\\u0646 \\u064A\\u062A\\u0636\\u0645\\u0651\\u064E\\u0646 \"${_issue.includes}\"`;\n if (_issue.format === \"regex\")\n return `\\u0646\\u064E\\u0635 \\u063A\\u064A\\u0631 \\u0645\\u0642\\u0628\\u0648\\u0644: \\u064A\\u062C\\u0628 \\u0623\\u0646 \\u064A\\u0637\\u0627\\u0628\\u0642 \\u0627\\u0644\\u0646\\u0645\\u0637 ${_issue.pattern}`;\n return `${FormatDictionary[_issue.format] ?? issue2.format} \\u063A\\u064A\\u0631 \\u0645\\u0642\\u0628\\u0648\\u0644`;\n }\n case \"not_multiple_of\":\n return `\\u0631\\u0642\\u0645 \\u063A\\u064A\\u0631 \\u0645\\u0642\\u0628\\u0648\\u0644: \\u064A\\u062C\\u0628 \\u0623\\u0646 \\u064A\\u0643\\u0648\\u0646 \\u0645\\u0646 \\u0645\\u0636\\u0627\\u0639\\u0641\\u0627\\u062A ${issue2.divisor}`;\n case \"unrecognized_keys\":\n return `\\u0645\\u0639\\u0631\\u0641${issue2.keys.length > 1 ? \"\\u0627\\u062A\" : \"\"} \\u063A\\u0631\\u064A\\u0628${issue2.keys.length > 1 ? \"\\u0629\" : \"\"}: ${joinValues(issue2.keys, \"\\u060C \")}`;\n case \"invalid_key\":\n return `\\u0645\\u0639\\u0631\\u0641 \\u063A\\u064A\\u0631 \\u0645\\u0642\\u0628\\u0648\\u0644 \\u0641\\u064A ${issue2.origin}`;\n case \"invalid_union\":\n return \"\\u0645\\u062F\\u062E\\u0644 \\u063A\\u064A\\u0631 \\u0645\\u0642\\u0628\\u0648\\u0644\";\n case \"invalid_element\":\n return `\\u0645\\u062F\\u062E\\u0644 \\u063A\\u064A\\u0631 \\u0645\\u0642\\u0628\\u0648\\u0644 \\u0641\\u064A ${issue2.origin}`;\n default:\n return \"\\u0645\\u062F\\u062E\\u0644 \\u063A\\u064A\\u0631 \\u0645\\u0642\\u0628\\u0648\\u0644\";\n }\n };\n };\n function ar_default() {\n return {\n localeError: error()\n };\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/az.js\n var error2 = () => {\n const Sizable = {\n string: { unit: \"simvol\", verb: \"olmal\\u0131d\\u0131r\" },\n file: { unit: \"bayt\", verb: \"olmal\\u0131d\\u0131r\" },\n array: { unit: \"element\", verb: \"olmal\\u0131d\\u0131r\" },\n set: { unit: \"element\", verb: \"olmal\\u0131d\\u0131r\" }\n };\n function getSizing(origin) {\n return Sizable[origin] ?? null;\n }\n const FormatDictionary = {\n regex: \"input\",\n email: \"email address\",\n url: \"URL\",\n emoji: \"emoji\",\n uuid: \"UUID\",\n uuidv4: \"UUIDv4\",\n uuidv6: \"UUIDv6\",\n nanoid: \"nanoid\",\n guid: \"GUID\",\n cuid: \"cuid\",\n cuid2: \"cuid2\",\n ulid: \"ULID\",\n xid: \"XID\",\n ksuid: \"KSUID\",\n datetime: \"ISO datetime\",\n date: \"ISO date\",\n time: \"ISO time\",\n duration: \"ISO duration\",\n ipv4: \"IPv4 address\",\n ipv6: \"IPv6 address\",\n cidrv4: \"IPv4 range\",\n cidrv6: \"IPv6 range\",\n base64: \"base64-encoded string\",\n base64url: \"base64url-encoded string\",\n json_string: \"JSON string\",\n e164: \"E.164 number\",\n jwt: \"JWT\",\n template_literal: \"input\"\n };\n const TypeDictionary = {\n nan: \"NaN\"\n };\n return (issue2) => {\n switch (issue2.code) {\n case \"invalid_type\": {\n const expected = TypeDictionary[issue2.expected] ?? issue2.expected;\n const receivedType = parsedType(issue2.input);\n const received = TypeDictionary[receivedType] ?? receivedType;\n if (/^[A-Z]/.test(issue2.expected)) {\n return `Yanl\\u0131\\u015F d\\u0259y\\u0259r: g\\xF6zl\\u0259nil\\u0259n instanceof ${issue2.expected}, daxil olan ${received}`;\n }\n return `Yanl\\u0131\\u015F d\\u0259y\\u0259r: g\\xF6zl\\u0259nil\\u0259n ${expected}, daxil olan ${received}`;\n }\n case \"invalid_value\":\n if (issue2.values.length === 1)\n return `Yanl\\u0131\\u015F d\\u0259y\\u0259r: g\\xF6zl\\u0259nil\\u0259n ${stringifyPrimitive(issue2.values[0])}`;\n return `Yanl\\u0131\\u015F se\\xE7im: a\\u015Fa\\u011F\\u0131dak\\u0131lardan biri olmal\\u0131d\\u0131r: ${joinValues(issue2.values, \"|\")}`;\n case \"too_big\": {\n const adj = issue2.inclusive ? \"<=\" : \"<\";\n const sizing = getSizing(issue2.origin);\n if (sizing)\n return `\\xC7ox b\\xF6y\\xFCk: g\\xF6zl\\u0259nil\\u0259n ${issue2.origin ?? \"d\\u0259y\\u0259r\"} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? \"element\"}`;\n return `\\xC7ox b\\xF6y\\xFCk: g\\xF6zl\\u0259nil\\u0259n ${issue2.origin ?? \"d\\u0259y\\u0259r\"} ${adj}${issue2.maximum.toString()}`;\n }\n case \"too_small\": {\n const adj = issue2.inclusive ? \">=\" : \">\";\n const sizing = getSizing(issue2.origin);\n if (sizing)\n return `\\xC7ox ki\\xE7ik: g\\xF6zl\\u0259nil\\u0259n ${issue2.origin} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;\n return `\\xC7ox ki\\xE7ik: g\\xF6zl\\u0259nil\\u0259n ${issue2.origin} ${adj}${issue2.minimum.toString()}`;\n }\n case \"invalid_format\": {\n const _issue = issue2;\n if (_issue.format === \"starts_with\")\n return `Yanl\\u0131\\u015F m\\u0259tn: \"${_issue.prefix}\" il\\u0259 ba\\u015Flamal\\u0131d\\u0131r`;\n if (_issue.format === \"ends_with\")\n return `Yanl\\u0131\\u015F m\\u0259tn: \"${_issue.suffix}\" il\\u0259 bitm\\u0259lidir`;\n if (_issue.format === \"includes\")\n return `Yanl\\u0131\\u015F m\\u0259tn: \"${_issue.includes}\" daxil olmal\\u0131d\\u0131r`;\n if (_issue.format === \"regex\")\n return `Yanl\\u0131\\u015F m\\u0259tn: ${_issue.pattern} \\u015Fablonuna uy\\u011Fun olmal\\u0131d\\u0131r`;\n return `Yanl\\u0131\\u015F ${FormatDictionary[_issue.format] ?? issue2.format}`;\n }\n case \"not_multiple_of\":\n return `Yanl\\u0131\\u015F \\u0259d\\u0259d: ${issue2.divisor} il\\u0259 b\\xF6l\\xFCn\\u0259 bil\\u0259n olmal\\u0131d\\u0131r`;\n case \"unrecognized_keys\":\n return `Tan\\u0131nmayan a\\xE7ar${issue2.keys.length > 1 ? \"lar\" : \"\"}: ${joinValues(issue2.keys, \", \")}`;\n case \"invalid_key\":\n return `${issue2.origin} daxilind\\u0259 yanl\\u0131\\u015F a\\xE7ar`;\n case \"invalid_union\":\n return \"Yanl\\u0131\\u015F d\\u0259y\\u0259r\";\n case \"invalid_element\":\n return `${issue2.origin} daxilind\\u0259 yanl\\u0131\\u015F d\\u0259y\\u0259r`;\n default:\n return `Yanl\\u0131\\u015F d\\u0259y\\u0259r`;\n }\n };\n };\n function az_default() {\n return {\n localeError: error2()\n };\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/be.js\n function getBelarusianPlural(count, one, few, many) {\n const absCount = Math.abs(count);\n const lastDigit = absCount % 10;\n const lastTwoDigits = absCount % 100;\n if (lastTwoDigits >= 11 && lastTwoDigits <= 19) {\n return many;\n }\n if (lastDigit === 1) {\n return one;\n }\n if (lastDigit >= 2 && lastDigit <= 4) {\n return few;\n }\n return many;\n }\n var error3 = () => {\n const Sizable = {\n string: {\n unit: {\n one: \"\\u0441\\u0456\\u043C\\u0432\\u0430\\u043B\",\n few: \"\\u0441\\u0456\\u043C\\u0432\\u0430\\u043B\\u044B\",\n many: \"\\u0441\\u0456\\u043C\\u0432\\u0430\\u043B\\u0430\\u045E\"\n },\n verb: \"\\u043C\\u0435\\u0446\\u044C\"\n },\n array: {\n unit: {\n one: \"\\u044D\\u043B\\u0435\\u043C\\u0435\\u043D\\u0442\",\n few: \"\\u044D\\u043B\\u0435\\u043C\\u0435\\u043D\\u0442\\u044B\",\n many: \"\\u044D\\u043B\\u0435\\u043C\\u0435\\u043D\\u0442\\u0430\\u045E\"\n },\n verb: \"\\u043C\\u0435\\u0446\\u044C\"\n },\n set: {\n unit: {\n one: \"\\u044D\\u043B\\u0435\\u043C\\u0435\\u043D\\u0442\",\n few: \"\\u044D\\u043B\\u0435\\u043C\\u0435\\u043D\\u0442\\u044B\",\n many: \"\\u044D\\u043B\\u0435\\u043C\\u0435\\u043D\\u0442\\u0430\\u045E\"\n },\n verb: \"\\u043C\\u0435\\u0446\\u044C\"\n },\n file: {\n unit: {\n one: \"\\u0431\\u0430\\u0439\\u0442\",\n few: \"\\u0431\\u0430\\u0439\\u0442\\u044B\",\n many: \"\\u0431\\u0430\\u0439\\u0442\\u0430\\u045E\"\n },\n verb: \"\\u043C\\u0435\\u0446\\u044C\"\n }\n };\n function getSizing(origin) {\n return Sizable[origin] ?? null;\n }\n const FormatDictionary = {\n regex: \"\\u0443\\u0432\\u043E\\u0434\",\n email: \"email \\u0430\\u0434\\u0440\\u0430\\u0441\",\n url: \"URL\",\n emoji: \"\\u044D\\u043C\\u043E\\u0434\\u0437\\u0456\",\n uuid: \"UUID\",\n uuidv4: \"UUIDv4\",\n uuidv6: \"UUIDv6\",\n nanoid: \"nanoid\",\n guid: \"GUID\",\n cuid: \"cuid\",\n cuid2: \"cuid2\",\n ulid: \"ULID\",\n xid: \"XID\",\n ksuid: \"KSUID\",\n datetime: \"ISO \\u0434\\u0430\\u0442\\u0430 \\u0456 \\u0447\\u0430\\u0441\",\n date: \"ISO \\u0434\\u0430\\u0442\\u0430\",\n time: \"ISO \\u0447\\u0430\\u0441\",\n duration: \"ISO \\u043F\\u0440\\u0430\\u0446\\u044F\\u0433\\u043B\\u0430\\u0441\\u0446\\u044C\",\n ipv4: \"IPv4 \\u0430\\u0434\\u0440\\u0430\\u0441\",\n ipv6: \"IPv6 \\u0430\\u0434\\u0440\\u0430\\u0441\",\n cidrv4: \"IPv4 \\u0434\\u044B\\u044F\\u043F\\u0430\\u0437\\u043E\\u043D\",\n cidrv6: \"IPv6 \\u0434\\u044B\\u044F\\u043F\\u0430\\u0437\\u043E\\u043D\",\n base64: \"\\u0440\\u0430\\u0434\\u043E\\u043A \\u0443 \\u0444\\u0430\\u0440\\u043C\\u0430\\u0446\\u0435 base64\",\n base64url: \"\\u0440\\u0430\\u0434\\u043E\\u043A \\u0443 \\u0444\\u0430\\u0440\\u043C\\u0430\\u0446\\u0435 base64url\",\n json_string: \"JSON \\u0440\\u0430\\u0434\\u043E\\u043A\",\n e164: \"\\u043D\\u0443\\u043C\\u0430\\u0440 E.164\",\n jwt: \"JWT\",\n template_literal: \"\\u0443\\u0432\\u043E\\u0434\"\n };\n const TypeDictionary = {\n nan: \"NaN\",\n number: \"\\u043B\\u0456\\u043A\",\n array: \"\\u043C\\u0430\\u0441\\u0456\\u045E\"\n };\n return (issue2) => {\n switch (issue2.code) {\n case \"invalid_type\": {\n const expected = TypeDictionary[issue2.expected] ?? issue2.expected;\n const receivedType = parsedType(issue2.input);\n const received = TypeDictionary[receivedType] ?? receivedType;\n if (/^[A-Z]/.test(issue2.expected)) {\n return `\\u041D\\u044F\\u043F\\u0440\\u0430\\u0432\\u0456\\u043B\\u044C\\u043D\\u044B \\u045E\\u0432\\u043E\\u0434: \\u0447\\u0430\\u043A\\u0430\\u045E\\u0441\\u044F instanceof ${issue2.expected}, \\u0430\\u0442\\u0440\\u044B\\u043C\\u0430\\u043D\\u0430 ${received}`;\n }\n return `\\u041D\\u044F\\u043F\\u0440\\u0430\\u0432\\u0456\\u043B\\u044C\\u043D\\u044B \\u045E\\u0432\\u043E\\u0434: \\u0447\\u0430\\u043A\\u0430\\u045E\\u0441\\u044F ${expected}, \\u0430\\u0442\\u0440\\u044B\\u043C\\u0430\\u043D\\u0430 ${received}`;\n }\n case \"invalid_value\":\n if (issue2.values.length === 1)\n return `\\u041D\\u044F\\u043F\\u0440\\u0430\\u0432\\u0456\\u043B\\u044C\\u043D\\u044B \\u045E\\u0432\\u043E\\u0434: \\u0447\\u0430\\u043A\\u0430\\u043B\\u0430\\u0441\\u044F ${stringifyPrimitive(issue2.values[0])}`;\n return `\\u041D\\u044F\\u043F\\u0440\\u0430\\u0432\\u0456\\u043B\\u044C\\u043D\\u044B \\u0432\\u0430\\u0440\\u044B\\u044F\\u043D\\u0442: \\u0447\\u0430\\u043A\\u0430\\u045E\\u0441\\u044F \\u0430\\u0434\\u0437\\u0456\\u043D \\u0437 ${joinValues(issue2.values, \"|\")}`;\n case \"too_big\": {\n const adj = issue2.inclusive ? \"<=\" : \"<\";\n const sizing = getSizing(issue2.origin);\n if (sizing) {\n const maxValue = Number(issue2.maximum);\n const unit = getBelarusianPlural(maxValue, sizing.unit.one, sizing.unit.few, sizing.unit.many);\n return `\\u0417\\u0430\\u043D\\u0430\\u0434\\u0442\\u0430 \\u0432\\u044F\\u043B\\u0456\\u043A\\u0456: \\u0447\\u0430\\u043A\\u0430\\u043B\\u0430\\u0441\\u044F, \\u0448\\u0442\\u043E ${issue2.origin ?? \"\\u0437\\u043D\\u0430\\u0447\\u044D\\u043D\\u043D\\u0435\"} \\u043F\\u0430\\u0432\\u0456\\u043D\\u043D\\u0430 ${sizing.verb} ${adj}${issue2.maximum.toString()} ${unit}`;\n }\n return `\\u0417\\u0430\\u043D\\u0430\\u0434\\u0442\\u0430 \\u0432\\u044F\\u043B\\u0456\\u043A\\u0456: \\u0447\\u0430\\u043A\\u0430\\u043B\\u0430\\u0441\\u044F, \\u0448\\u0442\\u043E ${issue2.origin ?? \"\\u0437\\u043D\\u0430\\u0447\\u044D\\u043D\\u043D\\u0435\"} \\u043F\\u0430\\u0432\\u0456\\u043D\\u043D\\u0430 \\u0431\\u044B\\u0446\\u044C ${adj}${issue2.maximum.toString()}`;\n }\n case \"too_small\": {\n const adj = issue2.inclusive ? \">=\" : \">\";\n const sizing = getSizing(issue2.origin);\n if (sizing) {\n const minValue = Number(issue2.minimum);\n const unit = getBelarusianPlural(minValue, sizing.unit.one, sizing.unit.few, sizing.unit.many);\n return `\\u0417\\u0430\\u043D\\u0430\\u0434\\u0442\\u0430 \\u043C\\u0430\\u043B\\u044B: \\u0447\\u0430\\u043A\\u0430\\u043B\\u0430\\u0441\\u044F, \\u0448\\u0442\\u043E ${issue2.origin} \\u043F\\u0430\\u0432\\u0456\\u043D\\u043D\\u0430 ${sizing.verb} ${adj}${issue2.minimum.toString()} ${unit}`;\n }\n return `\\u0417\\u0430\\u043D\\u0430\\u0434\\u0442\\u0430 \\u043C\\u0430\\u043B\\u044B: \\u0447\\u0430\\u043A\\u0430\\u043B\\u0430\\u0441\\u044F, \\u0448\\u0442\\u043E ${issue2.origin} \\u043F\\u0430\\u0432\\u0456\\u043D\\u043D\\u0430 \\u0431\\u044B\\u0446\\u044C ${adj}${issue2.minimum.toString()}`;\n }\n case \"invalid_format\": {\n const _issue = issue2;\n if (_issue.format === \"starts_with\")\n return `\\u041D\\u044F\\u043F\\u0440\\u0430\\u0432\\u0456\\u043B\\u044C\\u043D\\u044B \\u0440\\u0430\\u0434\\u043E\\u043A: \\u043F\\u0430\\u0432\\u0456\\u043D\\u0435\\u043D \\u043F\\u0430\\u0447\\u044B\\u043D\\u0430\\u0446\\u0446\\u0430 \\u0437 \"${_issue.prefix}\"`;\n if (_issue.format === \"ends_with\")\n return `\\u041D\\u044F\\u043F\\u0440\\u0430\\u0432\\u0456\\u043B\\u044C\\u043D\\u044B \\u0440\\u0430\\u0434\\u043E\\u043A: \\u043F\\u0430\\u0432\\u0456\\u043D\\u0435\\u043D \\u0437\\u0430\\u043A\\u0430\\u043D\\u0447\\u0432\\u0430\\u0446\\u0446\\u0430 \\u043D\\u0430 \"${_issue.suffix}\"`;\n if (_issue.format === \"includes\")\n return `\\u041D\\u044F\\u043F\\u0440\\u0430\\u0432\\u0456\\u043B\\u044C\\u043D\\u044B \\u0440\\u0430\\u0434\\u043E\\u043A: \\u043F\\u0430\\u0432\\u0456\\u043D\\u0435\\u043D \\u0437\\u043C\\u044F\\u0448\\u0447\\u0430\\u0446\\u044C \"${_issue.includes}\"`;\n if (_issue.format === \"regex\")\n return `\\u041D\\u044F\\u043F\\u0440\\u0430\\u0432\\u0456\\u043B\\u044C\\u043D\\u044B \\u0440\\u0430\\u0434\\u043E\\u043A: \\u043F\\u0430\\u0432\\u0456\\u043D\\u0435\\u043D \\u0430\\u0434\\u043F\\u0430\\u0432\\u044F\\u0434\\u0430\\u0446\\u044C \\u0448\\u0430\\u0431\\u043B\\u043E\\u043D\\u0443 ${_issue.pattern}`;\n return `\\u041D\\u044F\\u043F\\u0440\\u0430\\u0432\\u0456\\u043B\\u044C\\u043D\\u044B ${FormatDictionary[_issue.format] ?? issue2.format}`;\n }\n case \"not_multiple_of\":\n return `\\u041D\\u044F\\u043F\\u0440\\u0430\\u0432\\u0456\\u043B\\u044C\\u043D\\u044B \\u043B\\u0456\\u043A: \\u043F\\u0430\\u0432\\u0456\\u043D\\u0435\\u043D \\u0431\\u044B\\u0446\\u044C \\u043A\\u0440\\u0430\\u0442\\u043D\\u044B\\u043C ${issue2.divisor}`;\n case \"unrecognized_keys\":\n return `\\u041D\\u0435\\u0440\\u0430\\u0441\\u043F\\u0430\\u0437\\u043D\\u0430\\u043D\\u044B ${issue2.keys.length > 1 ? \"\\u043A\\u043B\\u044E\\u0447\\u044B\" : \"\\u043A\\u043B\\u044E\\u0447\"}: ${joinValues(issue2.keys, \", \")}`;\n case \"invalid_key\":\n return `\\u041D\\u044F\\u043F\\u0440\\u0430\\u0432\\u0456\\u043B\\u044C\\u043D\\u044B \\u043A\\u043B\\u044E\\u0447 \\u0443 ${issue2.origin}`;\n case \"invalid_union\":\n return \"\\u041D\\u044F\\u043F\\u0440\\u0430\\u0432\\u0456\\u043B\\u044C\\u043D\\u044B \\u045E\\u0432\\u043E\\u0434\";\n case \"invalid_element\":\n return `\\u041D\\u044F\\u043F\\u0440\\u0430\\u0432\\u0456\\u043B\\u044C\\u043D\\u0430\\u0435 \\u0437\\u043D\\u0430\\u0447\\u044D\\u043D\\u043D\\u0435 \\u045E ${issue2.origin}`;\n default:\n return `\\u041D\\u044F\\u043F\\u0440\\u0430\\u0432\\u0456\\u043B\\u044C\\u043D\\u044B \\u045E\\u0432\\u043E\\u0434`;\n }\n };\n };\n function be_default() {\n return {\n localeError: error3()\n };\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/bg.js\n var error4 = () => {\n const Sizable = {\n string: { unit: \"\\u0441\\u0438\\u043C\\u0432\\u043E\\u043B\\u0430\", verb: \"\\u0434\\u0430 \\u0441\\u044A\\u0434\\u044A\\u0440\\u0436\\u0430\" },\n file: { unit: \"\\u0431\\u0430\\u0439\\u0442\\u0430\", verb: \"\\u0434\\u0430 \\u0441\\u044A\\u0434\\u044A\\u0440\\u0436\\u0430\" },\n array: { unit: \"\\u0435\\u043B\\u0435\\u043C\\u0435\\u043D\\u0442\\u0430\", verb: \"\\u0434\\u0430 \\u0441\\u044A\\u0434\\u044A\\u0440\\u0436\\u0430\" },\n set: { unit: \"\\u0435\\u043B\\u0435\\u043C\\u0435\\u043D\\u0442\\u0430\", verb: \"\\u0434\\u0430 \\u0441\\u044A\\u0434\\u044A\\u0440\\u0436\\u0430\" }\n };\n function getSizing(origin) {\n return Sizable[origin] ?? null;\n }\n const FormatDictionary = {\n regex: \"\\u0432\\u0445\\u043E\\u0434\",\n email: \"\\u0438\\u043C\\u0435\\u0439\\u043B \\u0430\\u0434\\u0440\\u0435\\u0441\",\n url: \"URL\",\n emoji: \"\\u0435\\u043C\\u043E\\u0434\\u0436\\u0438\",\n uuid: \"UUID\",\n uuidv4: \"UUIDv4\",\n uuidv6: \"UUIDv6\",\n nanoid: \"nanoid\",\n guid: \"GUID\",\n cuid: \"cuid\",\n cuid2: \"cuid2\",\n ulid: \"ULID\",\n xid: \"XID\",\n ksuid: \"KSUID\",\n datetime: \"ISO \\u0432\\u0440\\u0435\\u043C\\u0435\",\n date: \"ISO \\u0434\\u0430\\u0442\\u0430\",\n time: \"ISO \\u0432\\u0440\\u0435\\u043C\\u0435\",\n duration: \"ISO \\u043F\\u0440\\u043E\\u0434\\u044A\\u043B\\u0436\\u0438\\u0442\\u0435\\u043B\\u043D\\u043E\\u0441\\u0442\",\n ipv4: \"IPv4 \\u0430\\u0434\\u0440\\u0435\\u0441\",\n ipv6: \"IPv6 \\u0430\\u0434\\u0440\\u0435\\u0441\",\n cidrv4: \"IPv4 \\u0434\\u0438\\u0430\\u043F\\u0430\\u0437\\u043E\\u043D\",\n cidrv6: \"IPv6 \\u0434\\u0438\\u0430\\u043F\\u0430\\u0437\\u043E\\u043D\",\n base64: \"base64-\\u043A\\u043E\\u0434\\u0438\\u0440\\u0430\\u043D \\u043D\\u0438\\u0437\",\n base64url: \"base64url-\\u043A\\u043E\\u0434\\u0438\\u0440\\u0430\\u043D \\u043D\\u0438\\u0437\",\n json_string: \"JSON \\u043D\\u0438\\u0437\",\n e164: \"E.164 \\u043D\\u043E\\u043C\\u0435\\u0440\",\n jwt: \"JWT\",\n template_literal: \"\\u0432\\u0445\\u043E\\u0434\"\n };\n const TypeDictionary = {\n nan: \"NaN\",\n number: \"\\u0447\\u0438\\u0441\\u043B\\u043E\",\n array: \"\\u043C\\u0430\\u0441\\u0438\\u0432\"\n };\n return (issue2) => {\n switch (issue2.code) {\n case \"invalid_type\": {\n const expected = TypeDictionary[issue2.expected] ?? issue2.expected;\n const receivedType = parsedType(issue2.input);\n const received = TypeDictionary[receivedType] ?? receivedType;\n if (/^[A-Z]/.test(issue2.expected)) {\n return `\\u041D\\u0435\\u0432\\u0430\\u043B\\u0438\\u0434\\u0435\\u043D \\u0432\\u0445\\u043E\\u0434: \\u043E\\u0447\\u0430\\u043A\\u0432\\u0430\\u043D instanceof ${issue2.expected}, \\u043F\\u043E\\u043B\\u0443\\u0447\\u0435\\u043D ${received}`;\n }\n return `\\u041D\\u0435\\u0432\\u0430\\u043B\\u0438\\u0434\\u0435\\u043D \\u0432\\u0445\\u043E\\u0434: \\u043E\\u0447\\u0430\\u043A\\u0432\\u0430\\u043D ${expected}, \\u043F\\u043E\\u043B\\u0443\\u0447\\u0435\\u043D ${received}`;\n }\n case \"invalid_value\":\n if (issue2.values.length === 1)\n return `\\u041D\\u0435\\u0432\\u0430\\u043B\\u0438\\u0434\\u0435\\u043D \\u0432\\u0445\\u043E\\u0434: \\u043E\\u0447\\u0430\\u043A\\u0432\\u0430\\u043D ${stringifyPrimitive(issue2.values[0])}`;\n return `\\u041D\\u0435\\u0432\\u0430\\u043B\\u0438\\u0434\\u043D\\u0430 \\u043E\\u043F\\u0446\\u0438\\u044F: \\u043E\\u0447\\u0430\\u043A\\u0432\\u0430\\u043D\\u043E \\u0435\\u0434\\u043D\\u043E \\u043E\\u0442 ${joinValues(issue2.values, \"|\")}`;\n case \"too_big\": {\n const adj = issue2.inclusive ? \"<=\" : \"<\";\n const sizing = getSizing(issue2.origin);\n if (sizing)\n return `\\u0422\\u0432\\u044A\\u0440\\u0434\\u0435 \\u0433\\u043E\\u043B\\u044F\\u043C\\u043E: \\u043E\\u0447\\u0430\\u043A\\u0432\\u0430 \\u0441\\u0435 ${issue2.origin ?? \"\\u0441\\u0442\\u043E\\u0439\\u043D\\u043E\\u0441\\u0442\"} \\u0434\\u0430 \\u0441\\u044A\\u0434\\u044A\\u0440\\u0436\\u0430 ${adj}${issue2.maximum.toString()} ${sizing.unit ?? \"\\u0435\\u043B\\u0435\\u043C\\u0435\\u043D\\u0442\\u0430\"}`;\n return `\\u0422\\u0432\\u044A\\u0440\\u0434\\u0435 \\u0433\\u043E\\u043B\\u044F\\u043C\\u043E: \\u043E\\u0447\\u0430\\u043A\\u0432\\u0430 \\u0441\\u0435 ${issue2.origin ?? \"\\u0441\\u0442\\u043E\\u0439\\u043D\\u043E\\u0441\\u0442\"} \\u0434\\u0430 \\u0431\\u044A\\u0434\\u0435 ${adj}${issue2.maximum.toString()}`;\n }\n case \"too_small\": {\n const adj = issue2.inclusive ? \">=\" : \">\";\n const sizing = getSizing(issue2.origin);\n if (sizing) {\n return `\\u0422\\u0432\\u044A\\u0440\\u0434\\u0435 \\u043C\\u0430\\u043B\\u043A\\u043E: \\u043E\\u0447\\u0430\\u043A\\u0432\\u0430 \\u0441\\u0435 ${issue2.origin} \\u0434\\u0430 \\u0441\\u044A\\u0434\\u044A\\u0440\\u0436\\u0430 ${adj}${issue2.minimum.toString()} ${sizing.unit}`;\n }\n return `\\u0422\\u0432\\u044A\\u0440\\u0434\\u0435 \\u043C\\u0430\\u043B\\u043A\\u043E: \\u043E\\u0447\\u0430\\u043A\\u0432\\u0430 \\u0441\\u0435 ${issue2.origin} \\u0434\\u0430 \\u0431\\u044A\\u0434\\u0435 ${adj}${issue2.minimum.toString()}`;\n }\n case \"invalid_format\": {\n const _issue = issue2;\n if (_issue.format === \"starts_with\") {\n return `\\u041D\\u0435\\u0432\\u0430\\u043B\\u0438\\u0434\\u0435\\u043D \\u043D\\u0438\\u0437: \\u0442\\u0440\\u044F\\u0431\\u0432\\u0430 \\u0434\\u0430 \\u0437\\u0430\\u043F\\u043E\\u0447\\u0432\\u0430 \\u0441 \"${_issue.prefix}\"`;\n }\n if (_issue.format === \"ends_with\")\n return `\\u041D\\u0435\\u0432\\u0430\\u043B\\u0438\\u0434\\u0435\\u043D \\u043D\\u0438\\u0437: \\u0442\\u0440\\u044F\\u0431\\u0432\\u0430 \\u0434\\u0430 \\u0437\\u0430\\u0432\\u044A\\u0440\\u0448\\u0432\\u0430 \\u0441 \"${_issue.suffix}\"`;\n if (_issue.format === \"includes\")\n return `\\u041D\\u0435\\u0432\\u0430\\u043B\\u0438\\u0434\\u0435\\u043D \\u043D\\u0438\\u0437: \\u0442\\u0440\\u044F\\u0431\\u0432\\u0430 \\u0434\\u0430 \\u0432\\u043A\\u043B\\u044E\\u0447\\u0432\\u0430 \"${_issue.includes}\"`;\n if (_issue.format === \"regex\")\n return `\\u041D\\u0435\\u0432\\u0430\\u043B\\u0438\\u0434\\u0435\\u043D \\u043D\\u0438\\u0437: \\u0442\\u0440\\u044F\\u0431\\u0432\\u0430 \\u0434\\u0430 \\u0441\\u044A\\u0432\\u043F\\u0430\\u0434\\u0430 \\u0441 ${_issue.pattern}`;\n let invalid_adj = \"\\u041D\\u0435\\u0432\\u0430\\u043B\\u0438\\u0434\\u0435\\u043D\";\n if (_issue.format === \"emoji\")\n invalid_adj = \"\\u041D\\u0435\\u0432\\u0430\\u043B\\u0438\\u0434\\u043D\\u043E\";\n if (_issue.format === \"datetime\")\n invalid_adj = \"\\u041D\\u0435\\u0432\\u0430\\u043B\\u0438\\u0434\\u043D\\u043E\";\n if (_issue.format === \"date\")\n invalid_adj = \"\\u041D\\u0435\\u0432\\u0430\\u043B\\u0438\\u0434\\u043D\\u0430\";\n if (_issue.format === \"time\")\n invalid_adj = \"\\u041D\\u0435\\u0432\\u0430\\u043B\\u0438\\u0434\\u043D\\u043E\";\n if (_issue.format === \"duration\")\n invalid_adj = \"\\u041D\\u0435\\u0432\\u0430\\u043B\\u0438\\u0434\\u043D\\u0430\";\n return `${invalid_adj} ${FormatDictionary[_issue.format] ?? issue2.format}`;\n }\n case \"not_multiple_of\":\n return `\\u041D\\u0435\\u0432\\u0430\\u043B\\u0438\\u0434\\u043D\\u043E \\u0447\\u0438\\u0441\\u043B\\u043E: \\u0442\\u0440\\u044F\\u0431\\u0432\\u0430 \\u0434\\u0430 \\u0431\\u044A\\u0434\\u0435 \\u043A\\u0440\\u0430\\u0442\\u043D\\u043E \\u043D\\u0430 ${issue2.divisor}`;\n case \"unrecognized_keys\":\n return `\\u041D\\u0435\\u0440\\u0430\\u0437\\u043F\\u043E\\u0437\\u043D\\u0430\\u0442${issue2.keys.length > 1 ? \"\\u0438\" : \"\"} \\u043A\\u043B\\u044E\\u0447${issue2.keys.length > 1 ? \"\\u043E\\u0432\\u0435\" : \"\"}: ${joinValues(issue2.keys, \", \")}`;\n case \"invalid_key\":\n return `\\u041D\\u0435\\u0432\\u0430\\u043B\\u0438\\u0434\\u0435\\u043D \\u043A\\u043B\\u044E\\u0447 \\u0432 ${issue2.origin}`;\n case \"invalid_union\":\n return \"\\u041D\\u0435\\u0432\\u0430\\u043B\\u0438\\u0434\\u0435\\u043D \\u0432\\u0445\\u043E\\u0434\";\n case \"invalid_element\":\n return `\\u041D\\u0435\\u0432\\u0430\\u043B\\u0438\\u0434\\u043D\\u0430 \\u0441\\u0442\\u043E\\u0439\\u043D\\u043E\\u0441\\u0442 \\u0432 ${issue2.origin}`;\n default:\n return `\\u041D\\u0435\\u0432\\u0430\\u043B\\u0438\\u0434\\u0435\\u043D \\u0432\\u0445\\u043E\\u0434`;\n }\n };\n };\n function bg_default() {\n return {\n localeError: error4()\n };\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/ca.js\n var error5 = () => {\n const Sizable = {\n string: { unit: \"car\\xE0cters\", verb: \"contenir\" },\n file: { unit: \"bytes\", verb: \"contenir\" },\n array: { unit: \"elements\", verb: \"contenir\" },\n set: { unit: \"elements\", verb: \"contenir\" }\n };\n function getSizing(origin) {\n return Sizable[origin] ?? null;\n }\n const FormatDictionary = {\n regex: \"entrada\",\n email: \"adre\\xE7a electr\\xF2nica\",\n url: \"URL\",\n emoji: \"emoji\",\n uuid: \"UUID\",\n uuidv4: \"UUIDv4\",\n uuidv6: \"UUIDv6\",\n nanoid: \"nanoid\",\n guid: \"GUID\",\n cuid: \"cuid\",\n cuid2: \"cuid2\",\n ulid: \"ULID\",\n xid: \"XID\",\n ksuid: \"KSUID\",\n datetime: \"data i hora ISO\",\n date: \"data ISO\",\n time: \"hora ISO\",\n duration: \"durada ISO\",\n ipv4: \"adre\\xE7a IPv4\",\n ipv6: \"adre\\xE7a IPv6\",\n cidrv4: \"rang IPv4\",\n cidrv6: \"rang IPv6\",\n base64: \"cadena codificada en base64\",\n base64url: \"cadena codificada en base64url\",\n json_string: \"cadena JSON\",\n e164: \"n\\xFAmero E.164\",\n jwt: \"JWT\",\n template_literal: \"entrada\"\n };\n const TypeDictionary = {\n nan: \"NaN\"\n };\n return (issue2) => {\n switch (issue2.code) {\n case \"invalid_type\": {\n const expected = TypeDictionary[issue2.expected] ?? issue2.expected;\n const receivedType = parsedType(issue2.input);\n const received = TypeDictionary[receivedType] ?? receivedType;\n if (/^[A-Z]/.test(issue2.expected)) {\n return `Tipus inv\\xE0lid: s'esperava instanceof ${issue2.expected}, s'ha rebut ${received}`;\n }\n return `Tipus inv\\xE0lid: s'esperava ${expected}, s'ha rebut ${received}`;\n }\n case \"invalid_value\":\n if (issue2.values.length === 1)\n return `Valor inv\\xE0lid: s'esperava ${stringifyPrimitive(issue2.values[0])}`;\n return `Opci\\xF3 inv\\xE0lida: s'esperava una de ${joinValues(issue2.values, \" o \")}`;\n case \"too_big\": {\n const adj = issue2.inclusive ? \"com a m\\xE0xim\" : \"menys de\";\n const sizing = getSizing(issue2.origin);\n if (sizing)\n return `Massa gran: s'esperava que ${issue2.origin ?? \"el valor\"} contingu\\xE9s ${adj} ${issue2.maximum.toString()} ${sizing.unit ?? \"elements\"}`;\n return `Massa gran: s'esperava que ${issue2.origin ?? \"el valor\"} fos ${adj} ${issue2.maximum.toString()}`;\n }\n case \"too_small\": {\n const adj = issue2.inclusive ? \"com a m\\xEDnim\" : \"m\\xE9s de\";\n const sizing = getSizing(issue2.origin);\n if (sizing) {\n return `Massa petit: s'esperava que ${issue2.origin} contingu\\xE9s ${adj} ${issue2.minimum.toString()} ${sizing.unit}`;\n }\n return `Massa petit: s'esperava que ${issue2.origin} fos ${adj} ${issue2.minimum.toString()}`;\n }\n case \"invalid_format\": {\n const _issue = issue2;\n if (_issue.format === \"starts_with\") {\n return `Format inv\\xE0lid: ha de comen\\xE7ar amb \"${_issue.prefix}\"`;\n }\n if (_issue.format === \"ends_with\")\n return `Format inv\\xE0lid: ha d'acabar amb \"${_issue.suffix}\"`;\n if (_issue.format === \"includes\")\n return `Format inv\\xE0lid: ha d'incloure \"${_issue.includes}\"`;\n if (_issue.format === \"regex\")\n return `Format inv\\xE0lid: ha de coincidir amb el patr\\xF3 ${_issue.pattern}`;\n return `Format inv\\xE0lid per a ${FormatDictionary[_issue.format] ?? issue2.format}`;\n }\n case \"not_multiple_of\":\n return `N\\xFAmero inv\\xE0lid: ha de ser m\\xFAltiple de ${issue2.divisor}`;\n case \"unrecognized_keys\":\n return `Clau${issue2.keys.length > 1 ? \"s\" : \"\"} no reconeguda${issue2.keys.length > 1 ? \"s\" : \"\"}: ${joinValues(issue2.keys, \", \")}`;\n case \"invalid_key\":\n return `Clau inv\\xE0lida a ${issue2.origin}`;\n case \"invalid_union\":\n return \"Entrada inv\\xE0lida\";\n // Could also be \"Tipus d'uni\u00f3 inv\u00e0lid\" but \"Entrada inv\u00e0lida\" is more general\n case \"invalid_element\":\n return `Element inv\\xE0lid a ${issue2.origin}`;\n default:\n return `Entrada inv\\xE0lida`;\n }\n };\n };\n function ca_default() {\n return {\n localeError: error5()\n };\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/cs.js\n var error6 = () => {\n const Sizable = {\n string: { unit: \"znak\\u016F\", verb: \"m\\xEDt\" },\n file: { unit: \"bajt\\u016F\", verb: \"m\\xEDt\" },\n array: { unit: \"prvk\\u016F\", verb: \"m\\xEDt\" },\n set: { unit: \"prvk\\u016F\", verb: \"m\\xEDt\" }\n };\n function getSizing(origin) {\n return Sizable[origin] ?? null;\n }\n const FormatDictionary = {\n regex: \"regul\\xE1rn\\xED v\\xFDraz\",\n email: \"e-mailov\\xE1 adresa\",\n url: \"URL\",\n emoji: \"emoji\",\n uuid: \"UUID\",\n uuidv4: \"UUIDv4\",\n uuidv6: \"UUIDv6\",\n nanoid: \"nanoid\",\n guid: \"GUID\",\n cuid: \"cuid\",\n cuid2: \"cuid2\",\n ulid: \"ULID\",\n xid: \"XID\",\n ksuid: \"KSUID\",\n datetime: \"datum a \\u010Das ve form\\xE1tu ISO\",\n date: \"datum ve form\\xE1tu ISO\",\n time: \"\\u010Das ve form\\xE1tu ISO\",\n duration: \"doba trv\\xE1n\\xED ISO\",\n ipv4: \"IPv4 adresa\",\n ipv6: \"IPv6 adresa\",\n cidrv4: \"rozsah IPv4\",\n cidrv6: \"rozsah IPv6\",\n base64: \"\\u0159et\\u011Bzec zak\\xF3dovan\\xFD ve form\\xE1tu base64\",\n base64url: \"\\u0159et\\u011Bzec zak\\xF3dovan\\xFD ve form\\xE1tu base64url\",\n json_string: \"\\u0159et\\u011Bzec ve form\\xE1tu JSON\",\n e164: \"\\u010D\\xEDslo E.164\",\n jwt: \"JWT\",\n template_literal: \"vstup\"\n };\n const TypeDictionary = {\n nan: \"NaN\",\n number: \"\\u010D\\xEDslo\",\n string: \"\\u0159et\\u011Bzec\",\n function: \"funkce\",\n array: \"pole\"\n };\n return (issue2) => {\n switch (issue2.code) {\n case \"invalid_type\": {\n const expected = TypeDictionary[issue2.expected] ?? issue2.expected;\n const receivedType = parsedType(issue2.input);\n const received = TypeDictionary[receivedType] ?? receivedType;\n if (/^[A-Z]/.test(issue2.expected)) {\n return `Neplatn\\xFD vstup: o\\u010Dek\\xE1v\\xE1no instanceof ${issue2.expected}, obdr\\u017Eeno ${received}`;\n }\n return `Neplatn\\xFD vstup: o\\u010Dek\\xE1v\\xE1no ${expected}, obdr\\u017Eeno ${received}`;\n }\n case \"invalid_value\":\n if (issue2.values.length === 1)\n return `Neplatn\\xFD vstup: o\\u010Dek\\xE1v\\xE1no ${stringifyPrimitive(issue2.values[0])}`;\n return `Neplatn\\xE1 mo\\u017Enost: o\\u010Dek\\xE1v\\xE1na jedna z hodnot ${joinValues(issue2.values, \"|\")}`;\n case \"too_big\": {\n const adj = issue2.inclusive ? \"<=\" : \"<\";\n const sizing = getSizing(issue2.origin);\n if (sizing) {\n return `Hodnota je p\\u0159\\xEDli\\u0161 velk\\xE1: ${issue2.origin ?? \"hodnota\"} mus\\xED m\\xEDt ${adj}${issue2.maximum.toString()} ${sizing.unit ?? \"prvk\\u016F\"}`;\n }\n return `Hodnota je p\\u0159\\xEDli\\u0161 velk\\xE1: ${issue2.origin ?? \"hodnota\"} mus\\xED b\\xFDt ${adj}${issue2.maximum.toString()}`;\n }\n case \"too_small\": {\n const adj = issue2.inclusive ? \">=\" : \">\";\n const sizing = getSizing(issue2.origin);\n if (sizing) {\n return `Hodnota je p\\u0159\\xEDli\\u0161 mal\\xE1: ${issue2.origin ?? \"hodnota\"} mus\\xED m\\xEDt ${adj}${issue2.minimum.toString()} ${sizing.unit ?? \"prvk\\u016F\"}`;\n }\n return `Hodnota je p\\u0159\\xEDli\\u0161 mal\\xE1: ${issue2.origin ?? \"hodnota\"} mus\\xED b\\xFDt ${adj}${issue2.minimum.toString()}`;\n }\n case \"invalid_format\": {\n const _issue = issue2;\n if (_issue.format === \"starts_with\")\n return `Neplatn\\xFD \\u0159et\\u011Bzec: mus\\xED za\\u010D\\xEDnat na \"${_issue.prefix}\"`;\n if (_issue.format === \"ends_with\")\n return `Neplatn\\xFD \\u0159et\\u011Bzec: mus\\xED kon\\u010Dit na \"${_issue.suffix}\"`;\n if (_issue.format === \"includes\")\n return `Neplatn\\xFD \\u0159et\\u011Bzec: mus\\xED obsahovat \"${_issue.includes}\"`;\n if (_issue.format === \"regex\")\n return `Neplatn\\xFD \\u0159et\\u011Bzec: mus\\xED odpov\\xEDdat vzoru ${_issue.pattern}`;\n return `Neplatn\\xFD form\\xE1t ${FormatDictionary[_issue.format] ?? issue2.format}`;\n }\n case \"not_multiple_of\":\n return `Neplatn\\xE9 \\u010D\\xEDslo: mus\\xED b\\xFDt n\\xE1sobkem ${issue2.divisor}`;\n case \"unrecognized_keys\":\n return `Nezn\\xE1m\\xE9 kl\\xED\\u010De: ${joinValues(issue2.keys, \", \")}`;\n case \"invalid_key\":\n return `Neplatn\\xFD kl\\xED\\u010D v ${issue2.origin}`;\n case \"invalid_union\":\n return \"Neplatn\\xFD vstup\";\n case \"invalid_element\":\n return `Neplatn\\xE1 hodnota v ${issue2.origin}`;\n default:\n return `Neplatn\\xFD vstup`;\n }\n };\n };\n function cs_default() {\n return {\n localeError: error6()\n };\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/da.js\n var error7 = () => {\n const Sizable = {\n string: { unit: \"tegn\", verb: \"havde\" },\n file: { unit: \"bytes\", verb: \"havde\" },\n array: { unit: \"elementer\", verb: \"indeholdt\" },\n set: { unit: \"elementer\", verb: \"indeholdt\" }\n };\n function getSizing(origin) {\n return Sizable[origin] ?? null;\n }\n const FormatDictionary = {\n regex: \"input\",\n email: \"e-mailadresse\",\n url: \"URL\",\n emoji: \"emoji\",\n uuid: \"UUID\",\n uuidv4: \"UUIDv4\",\n uuidv6: \"UUIDv6\",\n nanoid: \"nanoid\",\n guid: \"GUID\",\n cuid: \"cuid\",\n cuid2: \"cuid2\",\n ulid: \"ULID\",\n xid: \"XID\",\n ksuid: \"KSUID\",\n datetime: \"ISO dato- og klokkesl\\xE6t\",\n date: \"ISO-dato\",\n time: \"ISO-klokkesl\\xE6t\",\n duration: \"ISO-varighed\",\n ipv4: \"IPv4-omr\\xE5de\",\n ipv6: \"IPv6-omr\\xE5de\",\n cidrv4: \"IPv4-spektrum\",\n cidrv6: \"IPv6-spektrum\",\n base64: \"base64-kodet streng\",\n base64url: \"base64url-kodet streng\",\n json_string: \"JSON-streng\",\n e164: \"E.164-nummer\",\n jwt: \"JWT\",\n template_literal: \"input\"\n };\n const TypeDictionary = {\n nan: \"NaN\",\n string: \"streng\",\n number: \"tal\",\n boolean: \"boolean\",\n array: \"liste\",\n object: \"objekt\",\n set: \"s\\xE6t\",\n file: \"fil\"\n };\n return (issue2) => {\n switch (issue2.code) {\n case \"invalid_type\": {\n const expected = TypeDictionary[issue2.expected] ?? issue2.expected;\n const receivedType = parsedType(issue2.input);\n const received = TypeDictionary[receivedType] ?? receivedType;\n if (/^[A-Z]/.test(issue2.expected)) {\n return `Ugyldigt input: forventede instanceof ${issue2.expected}, fik ${received}`;\n }\n return `Ugyldigt input: forventede ${expected}, fik ${received}`;\n }\n case \"invalid_value\":\n if (issue2.values.length === 1)\n return `Ugyldig v\\xE6rdi: forventede ${stringifyPrimitive(issue2.values[0])}`;\n return `Ugyldigt valg: forventede en af f\\xF8lgende ${joinValues(issue2.values, \"|\")}`;\n case \"too_big\": {\n const adj = issue2.inclusive ? \"<=\" : \"<\";\n const sizing = getSizing(issue2.origin);\n const origin = TypeDictionary[issue2.origin] ?? issue2.origin;\n if (sizing)\n return `For stor: forventede ${origin ?? \"value\"} ${sizing.verb} ${adj} ${issue2.maximum.toString()} ${sizing.unit ?? \"elementer\"}`;\n return `For stor: forventede ${origin ?? \"value\"} havde ${adj} ${issue2.maximum.toString()}`;\n }\n case \"too_small\": {\n const adj = issue2.inclusive ? \">=\" : \">\";\n const sizing = getSizing(issue2.origin);\n const origin = TypeDictionary[issue2.origin] ?? issue2.origin;\n if (sizing) {\n return `For lille: forventede ${origin} ${sizing.verb} ${adj} ${issue2.minimum.toString()} ${sizing.unit}`;\n }\n return `For lille: forventede ${origin} havde ${adj} ${issue2.minimum.toString()}`;\n }\n case \"invalid_format\": {\n const _issue = issue2;\n if (_issue.format === \"starts_with\")\n return `Ugyldig streng: skal starte med \"${_issue.prefix}\"`;\n if (_issue.format === \"ends_with\")\n return `Ugyldig streng: skal ende med \"${_issue.suffix}\"`;\n if (_issue.format === \"includes\")\n return `Ugyldig streng: skal indeholde \"${_issue.includes}\"`;\n if (_issue.format === \"regex\")\n return `Ugyldig streng: skal matche m\\xF8nsteret ${_issue.pattern}`;\n return `Ugyldig ${FormatDictionary[_issue.format] ?? issue2.format}`;\n }\n case \"not_multiple_of\":\n return `Ugyldigt tal: skal v\\xE6re deleligt med ${issue2.divisor}`;\n case \"unrecognized_keys\":\n return `${issue2.keys.length > 1 ? \"Ukendte n\\xF8gler\" : \"Ukendt n\\xF8gle\"}: ${joinValues(issue2.keys, \", \")}`;\n case \"invalid_key\":\n return `Ugyldig n\\xF8gle i ${issue2.origin}`;\n case \"invalid_union\":\n return \"Ugyldigt input: matcher ingen af de tilladte typer\";\n case \"invalid_element\":\n return `Ugyldig v\\xE6rdi i ${issue2.origin}`;\n default:\n return `Ugyldigt input`;\n }\n };\n };\n function da_default() {\n return {\n localeError: error7()\n };\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/de.js\n var error8 = () => {\n const Sizable = {\n string: { unit: \"Zeichen\", verb: \"zu haben\" },\n file: { unit: \"Bytes\", verb: \"zu haben\" },\n array: { unit: \"Elemente\", verb: \"zu haben\" },\n set: { unit: \"Elemente\", verb: \"zu haben\" }\n };\n function getSizing(origin) {\n return Sizable[origin] ?? null;\n }\n const FormatDictionary = {\n regex: \"Eingabe\",\n email: \"E-Mail-Adresse\",\n url: \"URL\",\n emoji: \"Emoji\",\n uuid: \"UUID\",\n uuidv4: \"UUIDv4\",\n uuidv6: \"UUIDv6\",\n nanoid: \"nanoid\",\n guid: \"GUID\",\n cuid: \"cuid\",\n cuid2: \"cuid2\",\n ulid: \"ULID\",\n xid: \"XID\",\n ksuid: \"KSUID\",\n datetime: \"ISO-Datum und -Uhrzeit\",\n date: \"ISO-Datum\",\n time: \"ISO-Uhrzeit\",\n duration: \"ISO-Dauer\",\n ipv4: \"IPv4-Adresse\",\n ipv6: \"IPv6-Adresse\",\n cidrv4: \"IPv4-Bereich\",\n cidrv6: \"IPv6-Bereich\",\n base64: \"Base64-codierter String\",\n base64url: \"Base64-URL-codierter String\",\n json_string: \"JSON-String\",\n e164: \"E.164-Nummer\",\n jwt: \"JWT\",\n template_literal: \"Eingabe\"\n };\n const TypeDictionary = {\n nan: \"NaN\",\n number: \"Zahl\",\n array: \"Array\"\n };\n return (issue2) => {\n switch (issue2.code) {\n case \"invalid_type\": {\n const expected = TypeDictionary[issue2.expected] ?? issue2.expected;\n const receivedType = parsedType(issue2.input);\n const received = TypeDictionary[receivedType] ?? receivedType;\n if (/^[A-Z]/.test(issue2.expected)) {\n return `Ung\\xFCltige Eingabe: erwartet instanceof ${issue2.expected}, erhalten ${received}`;\n }\n return `Ung\\xFCltige Eingabe: erwartet ${expected}, erhalten ${received}`;\n }\n case \"invalid_value\":\n if (issue2.values.length === 1)\n return `Ung\\xFCltige Eingabe: erwartet ${stringifyPrimitive(issue2.values[0])}`;\n return `Ung\\xFCltige Option: erwartet eine von ${joinValues(issue2.values, \"|\")}`;\n case \"too_big\": {\n const adj = issue2.inclusive ? \"<=\" : \"<\";\n const sizing = getSizing(issue2.origin);\n if (sizing)\n return `Zu gro\\xDF: erwartet, dass ${issue2.origin ?? \"Wert\"} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? \"Elemente\"} hat`;\n return `Zu gro\\xDF: erwartet, dass ${issue2.origin ?? \"Wert\"} ${adj}${issue2.maximum.toString()} ist`;\n }\n case \"too_small\": {\n const adj = issue2.inclusive ? \">=\" : \">\";\n const sizing = getSizing(issue2.origin);\n if (sizing) {\n return `Zu klein: erwartet, dass ${issue2.origin} ${adj}${issue2.minimum.toString()} ${sizing.unit} hat`;\n }\n return `Zu klein: erwartet, dass ${issue2.origin} ${adj}${issue2.minimum.toString()} ist`;\n }\n case \"invalid_format\": {\n const _issue = issue2;\n if (_issue.format === \"starts_with\")\n return `Ung\\xFCltiger String: muss mit \"${_issue.prefix}\" beginnen`;\n if (_issue.format === \"ends_with\")\n return `Ung\\xFCltiger String: muss mit \"${_issue.suffix}\" enden`;\n if (_issue.format === \"includes\")\n return `Ung\\xFCltiger String: muss \"${_issue.includes}\" enthalten`;\n if (_issue.format === \"regex\")\n return `Ung\\xFCltiger String: muss dem Muster ${_issue.pattern} entsprechen`;\n return `Ung\\xFCltig: ${FormatDictionary[_issue.format] ?? issue2.format}`;\n }\n case \"not_multiple_of\":\n return `Ung\\xFCltige Zahl: muss ein Vielfaches von ${issue2.divisor} sein`;\n case \"unrecognized_keys\":\n return `${issue2.keys.length > 1 ? \"Unbekannte Schl\\xFCssel\" : \"Unbekannter Schl\\xFCssel\"}: ${joinValues(issue2.keys, \", \")}`;\n case \"invalid_key\":\n return `Ung\\xFCltiger Schl\\xFCssel in ${issue2.origin}`;\n case \"invalid_union\":\n return \"Ung\\xFCltige Eingabe\";\n case \"invalid_element\":\n return `Ung\\xFCltiger Wert in ${issue2.origin}`;\n default:\n return `Ung\\xFCltige Eingabe`;\n }\n };\n };\n function de_default() {\n return {\n localeError: error8()\n };\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/en.js\n var error9 = () => {\n const Sizable = {\n string: { unit: \"characters\", verb: \"to have\" },\n file: { unit: \"bytes\", verb: \"to have\" },\n array: { unit: \"items\", verb: \"to have\" },\n set: { unit: \"items\", verb: \"to have\" },\n map: { unit: \"entries\", verb: \"to have\" }\n };\n function getSizing(origin) {\n return Sizable[origin] ?? null;\n }\n const FormatDictionary = {\n regex: \"input\",\n email: \"email address\",\n url: \"URL\",\n emoji: \"emoji\",\n uuid: \"UUID\",\n uuidv4: \"UUIDv4\",\n uuidv6: \"UUIDv6\",\n nanoid: \"nanoid\",\n guid: \"GUID\",\n cuid: \"cuid\",\n cuid2: \"cuid2\",\n ulid: \"ULID\",\n xid: \"XID\",\n ksuid: \"KSUID\",\n datetime: \"ISO datetime\",\n date: \"ISO date\",\n time: \"ISO time\",\n duration: \"ISO duration\",\n ipv4: \"IPv4 address\",\n ipv6: \"IPv6 address\",\n mac: \"MAC address\",\n cidrv4: \"IPv4 range\",\n cidrv6: \"IPv6 range\",\n base64: \"base64-encoded string\",\n base64url: \"base64url-encoded string\",\n json_string: \"JSON string\",\n e164: \"E.164 number\",\n jwt: \"JWT\",\n template_literal: \"input\"\n };\n const TypeDictionary = {\n // Compatibility: \"nan\" -> \"NaN\" for display\n nan: \"NaN\"\n // All other type names omitted - they fall back to raw values via ?? operator\n };\n return (issue2) => {\n switch (issue2.code) {\n case \"invalid_type\": {\n const expected = TypeDictionary[issue2.expected] ?? issue2.expected;\n const receivedType = parsedType(issue2.input);\n const received = TypeDictionary[receivedType] ?? receivedType;\n return `Invalid input: expected ${expected}, received ${received}`;\n }\n case \"invalid_value\":\n if (issue2.values.length === 1)\n return `Invalid input: expected ${stringifyPrimitive(issue2.values[0])}`;\n return `Invalid option: expected one of ${joinValues(issue2.values, \"|\")}`;\n case \"too_big\": {\n const adj = issue2.inclusive ? \"<=\" : \"<\";\n const sizing = getSizing(issue2.origin);\n if (sizing)\n return `Too big: expected ${issue2.origin ?? \"value\"} to have ${adj}${issue2.maximum.toString()} ${sizing.unit ?? \"elements\"}`;\n return `Too big: expected ${issue2.origin ?? \"value\"} to be ${adj}${issue2.maximum.toString()}`;\n }\n case \"too_small\": {\n const adj = issue2.inclusive ? \">=\" : \">\";\n const sizing = getSizing(issue2.origin);\n if (sizing) {\n return `Too small: expected ${issue2.origin} to have ${adj}${issue2.minimum.toString()} ${sizing.unit}`;\n }\n return `Too small: expected ${issue2.origin} to be ${adj}${issue2.minimum.toString()}`;\n }\n case \"invalid_format\": {\n const _issue = issue2;\n if (_issue.format === \"starts_with\") {\n return `Invalid string: must start with \"${_issue.prefix}\"`;\n }\n if (_issue.format === \"ends_with\")\n return `Invalid string: must end with \"${_issue.suffix}\"`;\n if (_issue.format === \"includes\")\n return `Invalid string: must include \"${_issue.includes}\"`;\n if (_issue.format === \"regex\")\n return `Invalid string: must match pattern ${_issue.pattern}`;\n return `Invalid ${FormatDictionary[_issue.format] ?? issue2.format}`;\n }\n case \"not_multiple_of\":\n return `Invalid number: must be a multiple of ${issue2.divisor}`;\n case \"unrecognized_keys\":\n return `Unrecognized key${issue2.keys.length > 1 ? \"s\" : \"\"}: ${joinValues(issue2.keys, \", \")}`;\n case \"invalid_key\":\n return `Invalid key in ${issue2.origin}`;\n case \"invalid_union\":\n return \"Invalid input\";\n case \"invalid_element\":\n return `Invalid value in ${issue2.origin}`;\n default:\n return `Invalid input`;\n }\n };\n };\n function en_default() {\n return {\n localeError: error9()\n };\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/eo.js\n var error10 = () => {\n const Sizable = {\n string: { unit: \"karaktrojn\", verb: \"havi\" },\n file: { unit: \"bajtojn\", verb: \"havi\" },\n array: { unit: \"elementojn\", verb: \"havi\" },\n set: { unit: \"elementojn\", verb: \"havi\" }\n };\n function getSizing(origin) {\n return Sizable[origin] ?? null;\n }\n const FormatDictionary = {\n regex: \"enigo\",\n email: \"retadreso\",\n url: \"URL\",\n emoji: \"emo\\u011Dio\",\n uuid: \"UUID\",\n uuidv4: \"UUIDv4\",\n uuidv6: \"UUIDv6\",\n nanoid: \"nanoid\",\n guid: \"GUID\",\n cuid: \"cuid\",\n cuid2: \"cuid2\",\n ulid: \"ULID\",\n xid: \"XID\",\n ksuid: \"KSUID\",\n datetime: \"ISO-datotempo\",\n date: \"ISO-dato\",\n time: \"ISO-tempo\",\n duration: \"ISO-da\\u016Dro\",\n ipv4: \"IPv4-adreso\",\n ipv6: \"IPv6-adreso\",\n cidrv4: \"IPv4-rango\",\n cidrv6: \"IPv6-rango\",\n base64: \"64-ume kodita karaktraro\",\n base64url: \"URL-64-ume kodita karaktraro\",\n json_string: \"JSON-karaktraro\",\n e164: \"E.164-nombro\",\n jwt: \"JWT\",\n template_literal: \"enigo\"\n };\n const TypeDictionary = {\n nan: \"NaN\",\n number: \"nombro\",\n array: \"tabelo\",\n null: \"senvalora\"\n };\n return (issue2) => {\n switch (issue2.code) {\n case \"invalid_type\": {\n const expected = TypeDictionary[issue2.expected] ?? issue2.expected;\n const receivedType = parsedType(issue2.input);\n const received = TypeDictionary[receivedType] ?? receivedType;\n if (/^[A-Z]/.test(issue2.expected)) {\n return `Nevalida enigo: atendi\\u011Dis instanceof ${issue2.expected}, ricevi\\u011Dis ${received}`;\n }\n return `Nevalida enigo: atendi\\u011Dis ${expected}, ricevi\\u011Dis ${received}`;\n }\n case \"invalid_value\":\n if (issue2.values.length === 1)\n return `Nevalida enigo: atendi\\u011Dis ${stringifyPrimitive(issue2.values[0])}`;\n return `Nevalida opcio: atendi\\u011Dis unu el ${joinValues(issue2.values, \"|\")}`;\n case \"too_big\": {\n const adj = issue2.inclusive ? \"<=\" : \"<\";\n const sizing = getSizing(issue2.origin);\n if (sizing)\n return `Tro granda: atendi\\u011Dis ke ${issue2.origin ?? \"valoro\"} havu ${adj}${issue2.maximum.toString()} ${sizing.unit ?? \"elementojn\"}`;\n return `Tro granda: atendi\\u011Dis ke ${issue2.origin ?? \"valoro\"} havu ${adj}${issue2.maximum.toString()}`;\n }\n case \"too_small\": {\n const adj = issue2.inclusive ? \">=\" : \">\";\n const sizing = getSizing(issue2.origin);\n if (sizing) {\n return `Tro malgranda: atendi\\u011Dis ke ${issue2.origin} havu ${adj}${issue2.minimum.toString()} ${sizing.unit}`;\n }\n return `Tro malgranda: atendi\\u011Dis ke ${issue2.origin} estu ${adj}${issue2.minimum.toString()}`;\n }\n case \"invalid_format\": {\n const _issue = issue2;\n if (_issue.format === \"starts_with\")\n return `Nevalida karaktraro: devas komenci\\u011Di per \"${_issue.prefix}\"`;\n if (_issue.format === \"ends_with\")\n return `Nevalida karaktraro: devas fini\\u011Di per \"${_issue.suffix}\"`;\n if (_issue.format === \"includes\")\n return `Nevalida karaktraro: devas inkluzivi \"${_issue.includes}\"`;\n if (_issue.format === \"regex\")\n return `Nevalida karaktraro: devas kongrui kun la modelo ${_issue.pattern}`;\n return `Nevalida ${FormatDictionary[_issue.format] ?? issue2.format}`;\n }\n case \"not_multiple_of\":\n return `Nevalida nombro: devas esti oblo de ${issue2.divisor}`;\n case \"unrecognized_keys\":\n return `Nekonata${issue2.keys.length > 1 ? \"j\" : \"\"} \\u015Dlosilo${issue2.keys.length > 1 ? \"j\" : \"\"}: ${joinValues(issue2.keys, \", \")}`;\n case \"invalid_key\":\n return `Nevalida \\u015Dlosilo en ${issue2.origin}`;\n case \"invalid_union\":\n return \"Nevalida enigo\";\n case \"invalid_element\":\n return `Nevalida valoro en ${issue2.origin}`;\n default:\n return `Nevalida enigo`;\n }\n };\n };\n function eo_default() {\n return {\n localeError: error10()\n };\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/es.js\n var error11 = () => {\n const Sizable = {\n string: { unit: \"caracteres\", verb: \"tener\" },\n file: { unit: \"bytes\", verb: \"tener\" },\n array: { unit: \"elementos\", verb: \"tener\" },\n set: { unit: \"elementos\", verb: \"tener\" }\n };\n function getSizing(origin) {\n return Sizable[origin] ?? null;\n }\n const FormatDictionary = {\n regex: \"entrada\",\n email: \"direcci\\xF3n de correo electr\\xF3nico\",\n url: \"URL\",\n emoji: \"emoji\",\n uuid: \"UUID\",\n uuidv4: \"UUIDv4\",\n uuidv6: \"UUIDv6\",\n nanoid: \"nanoid\",\n guid: \"GUID\",\n cuid: \"cuid\",\n cuid2: \"cuid2\",\n ulid: \"ULID\",\n xid: \"XID\",\n ksuid: \"KSUID\",\n datetime: \"fecha y hora ISO\",\n date: \"fecha ISO\",\n time: \"hora ISO\",\n duration: \"duraci\\xF3n ISO\",\n ipv4: \"direcci\\xF3n IPv4\",\n ipv6: \"direcci\\xF3n IPv6\",\n cidrv4: \"rango IPv4\",\n cidrv6: \"rango IPv6\",\n base64: \"cadena codificada en base64\",\n base64url: \"URL codificada en base64\",\n json_string: \"cadena JSON\",\n e164: \"n\\xFAmero E.164\",\n jwt: \"JWT\",\n template_literal: \"entrada\"\n };\n const TypeDictionary = {\n nan: \"NaN\",\n string: \"texto\",\n number: \"n\\xFAmero\",\n boolean: \"booleano\",\n array: \"arreglo\",\n object: \"objeto\",\n set: \"conjunto\",\n file: \"archivo\",\n date: \"fecha\",\n bigint: \"n\\xFAmero grande\",\n symbol: \"s\\xEDmbolo\",\n undefined: \"indefinido\",\n null: \"nulo\",\n function: \"funci\\xF3n\",\n map: \"mapa\",\n record: \"registro\",\n tuple: \"tupla\",\n enum: \"enumeraci\\xF3n\",\n union: \"uni\\xF3n\",\n literal: \"literal\",\n promise: \"promesa\",\n void: \"vac\\xEDo\",\n never: \"nunca\",\n unknown: \"desconocido\",\n any: \"cualquiera\"\n };\n return (issue2) => {\n switch (issue2.code) {\n case \"invalid_type\": {\n const expected = TypeDictionary[issue2.expected] ?? issue2.expected;\n const receivedType = parsedType(issue2.input);\n const received = TypeDictionary[receivedType] ?? receivedType;\n if (/^[A-Z]/.test(issue2.expected)) {\n return `Entrada inv\\xE1lida: se esperaba instanceof ${issue2.expected}, recibido ${received}`;\n }\n return `Entrada inv\\xE1lida: se esperaba ${expected}, recibido ${received}`;\n }\n case \"invalid_value\":\n if (issue2.values.length === 1)\n return `Entrada inv\\xE1lida: se esperaba ${stringifyPrimitive(issue2.values[0])}`;\n return `Opci\\xF3n inv\\xE1lida: se esperaba una de ${joinValues(issue2.values, \"|\")}`;\n case \"too_big\": {\n const adj = issue2.inclusive ? \"<=\" : \"<\";\n const sizing = getSizing(issue2.origin);\n const origin = TypeDictionary[issue2.origin] ?? issue2.origin;\n if (sizing)\n return `Demasiado grande: se esperaba que ${origin ?? \"valor\"} tuviera ${adj}${issue2.maximum.toString()} ${sizing.unit ?? \"elementos\"}`;\n return `Demasiado grande: se esperaba que ${origin ?? \"valor\"} fuera ${adj}${issue2.maximum.toString()}`;\n }\n case \"too_small\": {\n const adj = issue2.inclusive ? \">=\" : \">\";\n const sizing = getSizing(issue2.origin);\n const origin = TypeDictionary[issue2.origin] ?? issue2.origin;\n if (sizing) {\n return `Demasiado peque\\xF1o: se esperaba que ${origin} tuviera ${adj}${issue2.minimum.toString()} ${sizing.unit}`;\n }\n return `Demasiado peque\\xF1o: se esperaba que ${origin} fuera ${adj}${issue2.minimum.toString()}`;\n }\n case \"invalid_format\": {\n const _issue = issue2;\n if (_issue.format === \"starts_with\")\n return `Cadena inv\\xE1lida: debe comenzar con \"${_issue.prefix}\"`;\n if (_issue.format === \"ends_with\")\n return `Cadena inv\\xE1lida: debe terminar en \"${_issue.suffix}\"`;\n if (_issue.format === \"includes\")\n return `Cadena inv\\xE1lida: debe incluir \"${_issue.includes}\"`;\n if (_issue.format === \"regex\")\n return `Cadena inv\\xE1lida: debe coincidir con el patr\\xF3n ${_issue.pattern}`;\n return `Inv\\xE1lido ${FormatDictionary[_issue.format] ?? issue2.format}`;\n }\n case \"not_multiple_of\":\n return `N\\xFAmero inv\\xE1lido: debe ser m\\xFAltiplo de ${issue2.divisor}`;\n case \"unrecognized_keys\":\n return `Llave${issue2.keys.length > 1 ? \"s\" : \"\"} desconocida${issue2.keys.length > 1 ? \"s\" : \"\"}: ${joinValues(issue2.keys, \", \")}`;\n case \"invalid_key\":\n return `Llave inv\\xE1lida en ${TypeDictionary[issue2.origin] ?? issue2.origin}`;\n case \"invalid_union\":\n return \"Entrada inv\\xE1lida\";\n case \"invalid_element\":\n return `Valor inv\\xE1lido en ${TypeDictionary[issue2.origin] ?? issue2.origin}`;\n default:\n return `Entrada inv\\xE1lida`;\n }\n };\n };\n function es_default() {\n return {\n localeError: error11()\n };\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/fa.js\n var error12 = () => {\n const Sizable = {\n string: { unit: \"\\u06A9\\u0627\\u0631\\u0627\\u06A9\\u062A\\u0631\", verb: \"\\u062F\\u0627\\u0634\\u062A\\u0647 \\u0628\\u0627\\u0634\\u062F\" },\n file: { unit: \"\\u0628\\u0627\\u06CC\\u062A\", verb: \"\\u062F\\u0627\\u0634\\u062A\\u0647 \\u0628\\u0627\\u0634\\u062F\" },\n array: { unit: \"\\u0622\\u06CC\\u062A\\u0645\", verb: \"\\u062F\\u0627\\u0634\\u062A\\u0647 \\u0628\\u0627\\u0634\\u062F\" },\n set: { unit: \"\\u0622\\u06CC\\u062A\\u0645\", verb: \"\\u062F\\u0627\\u0634\\u062A\\u0647 \\u0628\\u0627\\u0634\\u062F\" }\n };\n function getSizing(origin) {\n return Sizable[origin] ?? null;\n }\n const FormatDictionary = {\n regex: \"\\u0648\\u0631\\u0648\\u062F\\u06CC\",\n email: \"\\u0622\\u062F\\u0631\\u0633 \\u0627\\u06CC\\u0645\\u06CC\\u0644\",\n url: \"URL\",\n emoji: \"\\u0627\\u06CC\\u0645\\u0648\\u062C\\u06CC\",\n uuid: \"UUID\",\n uuidv4: \"UUIDv4\",\n uuidv6: \"UUIDv6\",\n nanoid: \"nanoid\",\n guid: \"GUID\",\n cuid: \"cuid\",\n cuid2: \"cuid2\",\n ulid: \"ULID\",\n xid: \"XID\",\n ksuid: \"KSUID\",\n datetime: \"\\u062A\\u0627\\u0631\\u06CC\\u062E \\u0648 \\u0632\\u0645\\u0627\\u0646 \\u0627\\u06CC\\u0632\\u0648\",\n date: \"\\u062A\\u0627\\u0631\\u06CC\\u062E \\u0627\\u06CC\\u0632\\u0648\",\n time: \"\\u0632\\u0645\\u0627\\u0646 \\u0627\\u06CC\\u0632\\u0648\",\n duration: \"\\u0645\\u062F\\u062A \\u0632\\u0645\\u0627\\u0646 \\u0627\\u06CC\\u0632\\u0648\",\n ipv4: \"IPv4 \\u0622\\u062F\\u0631\\u0633\",\n ipv6: \"IPv6 \\u0622\\u062F\\u0631\\u0633\",\n cidrv4: \"IPv4 \\u062F\\u0627\\u0645\\u0646\\u0647\",\n cidrv6: \"IPv6 \\u062F\\u0627\\u0645\\u0646\\u0647\",\n base64: \"base64-encoded \\u0631\\u0634\\u062A\\u0647\",\n base64url: \"base64url-encoded \\u0631\\u0634\\u062A\\u0647\",\n json_string: \"JSON \\u0631\\u0634\\u062A\\u0647\",\n e164: \"E.164 \\u0639\\u062F\\u062F\",\n jwt: \"JWT\",\n template_literal: \"\\u0648\\u0631\\u0648\\u062F\\u06CC\"\n };\n const TypeDictionary = {\n nan: \"NaN\",\n number: \"\\u0639\\u062F\\u062F\",\n array: \"\\u0622\\u0631\\u0627\\u06CC\\u0647\"\n };\n return (issue2) => {\n switch (issue2.code) {\n case \"invalid_type\": {\n const expected = TypeDictionary[issue2.expected] ?? issue2.expected;\n const receivedType = parsedType(issue2.input);\n const received = TypeDictionary[receivedType] ?? receivedType;\n if (/^[A-Z]/.test(issue2.expected)) {\n return `\\u0648\\u0631\\u0648\\u062F\\u06CC \\u0646\\u0627\\u0645\\u0639\\u062A\\u0628\\u0631: \\u0645\\u06CC\\u200C\\u0628\\u0627\\u06CC\\u0633\\u062A instanceof ${issue2.expected} \\u0645\\u06CC\\u200C\\u0628\\u0648\\u062F\\u060C ${received} \\u062F\\u0631\\u06CC\\u0627\\u0641\\u062A \\u0634\\u062F`;\n }\n return `\\u0648\\u0631\\u0648\\u062F\\u06CC \\u0646\\u0627\\u0645\\u0639\\u062A\\u0628\\u0631: \\u0645\\u06CC\\u200C\\u0628\\u0627\\u06CC\\u0633\\u062A ${expected} \\u0645\\u06CC\\u200C\\u0628\\u0648\\u062F\\u060C ${received} \\u062F\\u0631\\u06CC\\u0627\\u0641\\u062A \\u0634\\u062F`;\n }\n case \"invalid_value\":\n if (issue2.values.length === 1) {\n return `\\u0648\\u0631\\u0648\\u062F\\u06CC \\u0646\\u0627\\u0645\\u0639\\u062A\\u0628\\u0631: \\u0645\\u06CC\\u200C\\u0628\\u0627\\u06CC\\u0633\\u062A ${stringifyPrimitive(issue2.values[0])} \\u0645\\u06CC\\u200C\\u0628\\u0648\\u062F`;\n }\n return `\\u06AF\\u0632\\u06CC\\u0646\\u0647 \\u0646\\u0627\\u0645\\u0639\\u062A\\u0628\\u0631: \\u0645\\u06CC\\u200C\\u0628\\u0627\\u06CC\\u0633\\u062A \\u06CC\\u06A9\\u06CC \\u0627\\u0632 ${joinValues(issue2.values, \"|\")} \\u0645\\u06CC\\u200C\\u0628\\u0648\\u062F`;\n case \"too_big\": {\n const adj = issue2.inclusive ? \"<=\" : \"<\";\n const sizing = getSizing(issue2.origin);\n if (sizing) {\n return `\\u062E\\u06CC\\u0644\\u06CC \\u0628\\u0632\\u0631\\u06AF: ${issue2.origin ?? \"\\u0645\\u0642\\u062F\\u0627\\u0631\"} \\u0628\\u0627\\u06CC\\u062F ${adj}${issue2.maximum.toString()} ${sizing.unit ?? \"\\u0639\\u0646\\u0635\\u0631\"} \\u0628\\u0627\\u0634\\u062F`;\n }\n return `\\u062E\\u06CC\\u0644\\u06CC \\u0628\\u0632\\u0631\\u06AF: ${issue2.origin ?? \"\\u0645\\u0642\\u062F\\u0627\\u0631\"} \\u0628\\u0627\\u06CC\\u062F ${adj}${issue2.maximum.toString()} \\u0628\\u0627\\u0634\\u062F`;\n }\n case \"too_small\": {\n const adj = issue2.inclusive ? \">=\" : \">\";\n const sizing = getSizing(issue2.origin);\n if (sizing) {\n return `\\u062E\\u06CC\\u0644\\u06CC \\u06A9\\u0648\\u0686\\u06A9: ${issue2.origin} \\u0628\\u0627\\u06CC\\u062F ${adj}${issue2.minimum.toString()} ${sizing.unit} \\u0628\\u0627\\u0634\\u062F`;\n }\n return `\\u062E\\u06CC\\u0644\\u06CC \\u06A9\\u0648\\u0686\\u06A9: ${issue2.origin} \\u0628\\u0627\\u06CC\\u062F ${adj}${issue2.minimum.toString()} \\u0628\\u0627\\u0634\\u062F`;\n }\n case \"invalid_format\": {\n const _issue = issue2;\n if (_issue.format === \"starts_with\") {\n return `\\u0631\\u0634\\u062A\\u0647 \\u0646\\u0627\\u0645\\u0639\\u062A\\u0628\\u0631: \\u0628\\u0627\\u06CC\\u062F \\u0628\\u0627 \"${_issue.prefix}\" \\u0634\\u0631\\u0648\\u0639 \\u0634\\u0648\\u062F`;\n }\n if (_issue.format === \"ends_with\") {\n return `\\u0631\\u0634\\u062A\\u0647 \\u0646\\u0627\\u0645\\u0639\\u062A\\u0628\\u0631: \\u0628\\u0627\\u06CC\\u062F \\u0628\\u0627 \"${_issue.suffix}\" \\u062A\\u0645\\u0627\\u0645 \\u0634\\u0648\\u062F`;\n }\n if (_issue.format === \"includes\") {\n return `\\u0631\\u0634\\u062A\\u0647 \\u0646\\u0627\\u0645\\u0639\\u062A\\u0628\\u0631: \\u0628\\u0627\\u06CC\\u062F \\u0634\\u0627\\u0645\\u0644 \"${_issue.includes}\" \\u0628\\u0627\\u0634\\u062F`;\n }\n if (_issue.format === \"regex\") {\n return `\\u0631\\u0634\\u062A\\u0647 \\u0646\\u0627\\u0645\\u0639\\u062A\\u0628\\u0631: \\u0628\\u0627\\u06CC\\u062F \\u0628\\u0627 \\u0627\\u0644\\u06AF\\u0648\\u06CC ${_issue.pattern} \\u0645\\u0637\\u0627\\u0628\\u0642\\u062A \\u062F\\u0627\\u0634\\u062A\\u0647 \\u0628\\u0627\\u0634\\u062F`;\n }\n return `${FormatDictionary[_issue.format] ?? issue2.format} \\u0646\\u0627\\u0645\\u0639\\u062A\\u0628\\u0631`;\n }\n case \"not_multiple_of\":\n return `\\u0639\\u062F\\u062F \\u0646\\u0627\\u0645\\u0639\\u062A\\u0628\\u0631: \\u0628\\u0627\\u06CC\\u062F \\u0645\\u0636\\u0631\\u0628 ${issue2.divisor} \\u0628\\u0627\\u0634\\u062F`;\n case \"unrecognized_keys\":\n return `\\u06A9\\u0644\\u06CC\\u062F${issue2.keys.length > 1 ? \"\\u0647\\u0627\\u06CC\" : \"\"} \\u0646\\u0627\\u0634\\u0646\\u0627\\u0633: ${joinValues(issue2.keys, \", \")}`;\n case \"invalid_key\":\n return `\\u06A9\\u0644\\u06CC\\u062F \\u0646\\u0627\\u0634\\u0646\\u0627\\u0633 \\u062F\\u0631 ${issue2.origin}`;\n case \"invalid_union\":\n return `\\u0648\\u0631\\u0648\\u062F\\u06CC \\u0646\\u0627\\u0645\\u0639\\u062A\\u0628\\u0631`;\n case \"invalid_element\":\n return `\\u0645\\u0642\\u062F\\u0627\\u0631 \\u0646\\u0627\\u0645\\u0639\\u062A\\u0628\\u0631 \\u062F\\u0631 ${issue2.origin}`;\n default:\n return `\\u0648\\u0631\\u0648\\u062F\\u06CC \\u0646\\u0627\\u0645\\u0639\\u062A\\u0628\\u0631`;\n }\n };\n };\n function fa_default() {\n return {\n localeError: error12()\n };\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/fi.js\n var error13 = () => {\n const Sizable = {\n string: { unit: \"merkki\\xE4\", subject: \"merkkijonon\" },\n file: { unit: \"tavua\", subject: \"tiedoston\" },\n array: { unit: \"alkiota\", subject: \"listan\" },\n set: { unit: \"alkiota\", subject: \"joukon\" },\n number: { unit: \"\", subject: \"luvun\" },\n bigint: { unit: \"\", subject: \"suuren kokonaisluvun\" },\n int: { unit: \"\", subject: \"kokonaisluvun\" },\n date: { unit: \"\", subject: \"p\\xE4iv\\xE4m\\xE4\\xE4r\\xE4n\" }\n };\n function getSizing(origin) {\n return Sizable[origin] ?? null;\n }\n const FormatDictionary = {\n regex: \"s\\xE4\\xE4nn\\xF6llinen lauseke\",\n email: \"s\\xE4hk\\xF6postiosoite\",\n url: \"URL-osoite\",\n emoji: \"emoji\",\n uuid: \"UUID\",\n uuidv4: \"UUIDv4\",\n uuidv6: \"UUIDv6\",\n nanoid: \"nanoid\",\n guid: \"GUID\",\n cuid: \"cuid\",\n cuid2: \"cuid2\",\n ulid: \"ULID\",\n xid: \"XID\",\n ksuid: \"KSUID\",\n datetime: \"ISO-aikaleima\",\n date: \"ISO-p\\xE4iv\\xE4m\\xE4\\xE4r\\xE4\",\n time: \"ISO-aika\",\n duration: \"ISO-kesto\",\n ipv4: \"IPv4-osoite\",\n ipv6: \"IPv6-osoite\",\n cidrv4: \"IPv4-alue\",\n cidrv6: \"IPv6-alue\",\n base64: \"base64-koodattu merkkijono\",\n base64url: \"base64url-koodattu merkkijono\",\n json_string: \"JSON-merkkijono\",\n e164: \"E.164-luku\",\n jwt: \"JWT\",\n template_literal: \"templaattimerkkijono\"\n };\n const TypeDictionary = {\n nan: \"NaN\"\n };\n return (issue2) => {\n switch (issue2.code) {\n case \"invalid_type\": {\n const expected = TypeDictionary[issue2.expected] ?? issue2.expected;\n const receivedType = parsedType(issue2.input);\n const received = TypeDictionary[receivedType] ?? receivedType;\n if (/^[A-Z]/.test(issue2.expected)) {\n return `Virheellinen tyyppi: odotettiin instanceof ${issue2.expected}, oli ${received}`;\n }\n return `Virheellinen tyyppi: odotettiin ${expected}, oli ${received}`;\n }\n case \"invalid_value\":\n if (issue2.values.length === 1)\n return `Virheellinen sy\\xF6te: t\\xE4ytyy olla ${stringifyPrimitive(issue2.values[0])}`;\n return `Virheellinen valinta: t\\xE4ytyy olla yksi seuraavista: ${joinValues(issue2.values, \"|\")}`;\n case \"too_big\": {\n const adj = issue2.inclusive ? \"<=\" : \"<\";\n const sizing = getSizing(issue2.origin);\n if (sizing) {\n return `Liian suuri: ${sizing.subject} t\\xE4ytyy olla ${adj}${issue2.maximum.toString()} ${sizing.unit}`.trim();\n }\n return `Liian suuri: arvon t\\xE4ytyy olla ${adj}${issue2.maximum.toString()}`;\n }\n case \"too_small\": {\n const adj = issue2.inclusive ? \">=\" : \">\";\n const sizing = getSizing(issue2.origin);\n if (sizing) {\n return `Liian pieni: ${sizing.subject} t\\xE4ytyy olla ${adj}${issue2.minimum.toString()} ${sizing.unit}`.trim();\n }\n return `Liian pieni: arvon t\\xE4ytyy olla ${adj}${issue2.minimum.toString()}`;\n }\n case \"invalid_format\": {\n const _issue = issue2;\n if (_issue.format === \"starts_with\")\n return `Virheellinen sy\\xF6te: t\\xE4ytyy alkaa \"${_issue.prefix}\"`;\n if (_issue.format === \"ends_with\")\n return `Virheellinen sy\\xF6te: t\\xE4ytyy loppua \"${_issue.suffix}\"`;\n if (_issue.format === \"includes\")\n return `Virheellinen sy\\xF6te: t\\xE4ytyy sis\\xE4lt\\xE4\\xE4 \"${_issue.includes}\"`;\n if (_issue.format === \"regex\") {\n return `Virheellinen sy\\xF6te: t\\xE4ytyy vastata s\\xE4\\xE4nn\\xF6llist\\xE4 lauseketta ${_issue.pattern}`;\n }\n return `Virheellinen ${FormatDictionary[_issue.format] ?? issue2.format}`;\n }\n case \"not_multiple_of\":\n return `Virheellinen luku: t\\xE4ytyy olla luvun ${issue2.divisor} monikerta`;\n case \"unrecognized_keys\":\n return `${issue2.keys.length > 1 ? \"Tuntemattomat avaimet\" : \"Tuntematon avain\"}: ${joinValues(issue2.keys, \", \")}`;\n case \"invalid_key\":\n return \"Virheellinen avain tietueessa\";\n case \"invalid_union\":\n return \"Virheellinen unioni\";\n case \"invalid_element\":\n return \"Virheellinen arvo joukossa\";\n default:\n return `Virheellinen sy\\xF6te`;\n }\n };\n };\n function fi_default() {\n return {\n localeError: error13()\n };\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/fr.js\n var error14 = () => {\n const Sizable = {\n string: { unit: \"caract\\xE8res\", verb: \"avoir\" },\n file: { unit: \"octets\", verb: \"avoir\" },\n array: { unit: \"\\xE9l\\xE9ments\", verb: \"avoir\" },\n set: { unit: \"\\xE9l\\xE9ments\", verb: \"avoir\" }\n };\n function getSizing(origin) {\n return Sizable[origin] ?? null;\n }\n const FormatDictionary = {\n regex: \"entr\\xE9e\",\n email: \"adresse e-mail\",\n url: \"URL\",\n emoji: \"emoji\",\n uuid: \"UUID\",\n uuidv4: \"UUIDv4\",\n uuidv6: \"UUIDv6\",\n nanoid: \"nanoid\",\n guid: \"GUID\",\n cuid: \"cuid\",\n cuid2: \"cuid2\",\n ulid: \"ULID\",\n xid: \"XID\",\n ksuid: \"KSUID\",\n datetime: \"date et heure ISO\",\n date: \"date ISO\",\n time: \"heure ISO\",\n duration: \"dur\\xE9e ISO\",\n ipv4: \"adresse IPv4\",\n ipv6: \"adresse IPv6\",\n cidrv4: \"plage IPv4\",\n cidrv6: \"plage IPv6\",\n base64: \"cha\\xEEne encod\\xE9e en base64\",\n base64url: \"cha\\xEEne encod\\xE9e en base64url\",\n json_string: \"cha\\xEEne JSON\",\n e164: \"num\\xE9ro E.164\",\n jwt: \"JWT\",\n template_literal: \"entr\\xE9e\"\n };\n const TypeDictionary = {\n nan: \"NaN\",\n number: \"nombre\",\n array: \"tableau\"\n };\n return (issue2) => {\n switch (issue2.code) {\n case \"invalid_type\": {\n const expected = TypeDictionary[issue2.expected] ?? issue2.expected;\n const receivedType = parsedType(issue2.input);\n const received = TypeDictionary[receivedType] ?? receivedType;\n if (/^[A-Z]/.test(issue2.expected)) {\n return `Entr\\xE9e invalide : instanceof ${issue2.expected} attendu, ${received} re\\xE7u`;\n }\n return `Entr\\xE9e invalide : ${expected} attendu, ${received} re\\xE7u`;\n }\n case \"invalid_value\":\n if (issue2.values.length === 1)\n return `Entr\\xE9e invalide : ${stringifyPrimitive(issue2.values[0])} attendu`;\n return `Option invalide : une valeur parmi ${joinValues(issue2.values, \"|\")} attendue`;\n case \"too_big\": {\n const adj = issue2.inclusive ? \"<=\" : \"<\";\n const sizing = getSizing(issue2.origin);\n if (sizing)\n return `Trop grand : ${issue2.origin ?? \"valeur\"} doit ${sizing.verb} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? \"\\xE9l\\xE9ment(s)\"}`;\n return `Trop grand : ${issue2.origin ?? \"valeur\"} doit \\xEAtre ${adj}${issue2.maximum.toString()}`;\n }\n case \"too_small\": {\n const adj = issue2.inclusive ? \">=\" : \">\";\n const sizing = getSizing(issue2.origin);\n if (sizing) {\n return `Trop petit : ${issue2.origin} doit ${sizing.verb} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;\n }\n return `Trop petit : ${issue2.origin} doit \\xEAtre ${adj}${issue2.minimum.toString()}`;\n }\n case \"invalid_format\": {\n const _issue = issue2;\n if (_issue.format === \"starts_with\")\n return `Cha\\xEEne invalide : doit commencer par \"${_issue.prefix}\"`;\n if (_issue.format === \"ends_with\")\n return `Cha\\xEEne invalide : doit se terminer par \"${_issue.suffix}\"`;\n if (_issue.format === \"includes\")\n return `Cha\\xEEne invalide : doit inclure \"${_issue.includes}\"`;\n if (_issue.format === \"regex\")\n return `Cha\\xEEne invalide : doit correspondre au mod\\xE8le ${_issue.pattern}`;\n return `${FormatDictionary[_issue.format] ?? issue2.format} invalide`;\n }\n case \"not_multiple_of\":\n return `Nombre invalide : doit \\xEAtre un multiple de ${issue2.divisor}`;\n case \"unrecognized_keys\":\n return `Cl\\xE9${issue2.keys.length > 1 ? \"s\" : \"\"} non reconnue${issue2.keys.length > 1 ? \"s\" : \"\"} : ${joinValues(issue2.keys, \", \")}`;\n case \"invalid_key\":\n return `Cl\\xE9 invalide dans ${issue2.origin}`;\n case \"invalid_union\":\n return \"Entr\\xE9e invalide\";\n case \"invalid_element\":\n return `Valeur invalide dans ${issue2.origin}`;\n default:\n return `Entr\\xE9e invalide`;\n }\n };\n };\n function fr_default() {\n return {\n localeError: error14()\n };\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/fr-CA.js\n var error15 = () => {\n const Sizable = {\n string: { unit: \"caract\\xE8res\", verb: \"avoir\" },\n file: { unit: \"octets\", verb: \"avoir\" },\n array: { unit: \"\\xE9l\\xE9ments\", verb: \"avoir\" },\n set: { unit: \"\\xE9l\\xE9ments\", verb: \"avoir\" }\n };\n function getSizing(origin) {\n return Sizable[origin] ?? null;\n }\n const FormatDictionary = {\n regex: \"entr\\xE9e\",\n email: \"adresse courriel\",\n url: \"URL\",\n emoji: \"emoji\",\n uuid: \"UUID\",\n uuidv4: \"UUIDv4\",\n uuidv6: \"UUIDv6\",\n nanoid: \"nanoid\",\n guid: \"GUID\",\n cuid: \"cuid\",\n cuid2: \"cuid2\",\n ulid: \"ULID\",\n xid: \"XID\",\n ksuid: \"KSUID\",\n datetime: \"date-heure ISO\",\n date: \"date ISO\",\n time: \"heure ISO\",\n duration: \"dur\\xE9e ISO\",\n ipv4: \"adresse IPv4\",\n ipv6: \"adresse IPv6\",\n cidrv4: \"plage IPv4\",\n cidrv6: \"plage IPv6\",\n base64: \"cha\\xEEne encod\\xE9e en base64\",\n base64url: \"cha\\xEEne encod\\xE9e en base64url\",\n json_string: \"cha\\xEEne JSON\",\n e164: \"num\\xE9ro E.164\",\n jwt: \"JWT\",\n template_literal: \"entr\\xE9e\"\n };\n const TypeDictionary = {\n nan: \"NaN\"\n };\n return (issue2) => {\n switch (issue2.code) {\n case \"invalid_type\": {\n const expected = TypeDictionary[issue2.expected] ?? issue2.expected;\n const receivedType = parsedType(issue2.input);\n const received = TypeDictionary[receivedType] ?? receivedType;\n if (/^[A-Z]/.test(issue2.expected)) {\n return `Entr\\xE9e invalide : attendu instanceof ${issue2.expected}, re\\xE7u ${received}`;\n }\n return `Entr\\xE9e invalide : attendu ${expected}, re\\xE7u ${received}`;\n }\n case \"invalid_value\":\n if (issue2.values.length === 1)\n return `Entr\\xE9e invalide : attendu ${stringifyPrimitive(issue2.values[0])}`;\n return `Option invalide : attendu l'une des valeurs suivantes ${joinValues(issue2.values, \"|\")}`;\n case \"too_big\": {\n const adj = issue2.inclusive ? \"\\u2264\" : \"<\";\n const sizing = getSizing(issue2.origin);\n if (sizing)\n return `Trop grand : attendu que ${issue2.origin ?? \"la valeur\"} ait ${adj}${issue2.maximum.toString()} ${sizing.unit}`;\n return `Trop grand : attendu que ${issue2.origin ?? \"la valeur\"} soit ${adj}${issue2.maximum.toString()}`;\n }\n case \"too_small\": {\n const adj = issue2.inclusive ? \"\\u2265\" : \">\";\n const sizing = getSizing(issue2.origin);\n if (sizing) {\n return `Trop petit : attendu que ${issue2.origin} ait ${adj}${issue2.minimum.toString()} ${sizing.unit}`;\n }\n return `Trop petit : attendu que ${issue2.origin} soit ${adj}${issue2.minimum.toString()}`;\n }\n case \"invalid_format\": {\n const _issue = issue2;\n if (_issue.format === \"starts_with\") {\n return `Cha\\xEEne invalide : doit commencer par \"${_issue.prefix}\"`;\n }\n if (_issue.format === \"ends_with\")\n return `Cha\\xEEne invalide : doit se terminer par \"${_issue.suffix}\"`;\n if (_issue.format === \"includes\")\n return `Cha\\xEEne invalide : doit inclure \"${_issue.includes}\"`;\n if (_issue.format === \"regex\")\n return `Cha\\xEEne invalide : doit correspondre au motif ${_issue.pattern}`;\n return `${FormatDictionary[_issue.format] ?? issue2.format} invalide`;\n }\n case \"not_multiple_of\":\n return `Nombre invalide : doit \\xEAtre un multiple de ${issue2.divisor}`;\n case \"unrecognized_keys\":\n return `Cl\\xE9${issue2.keys.length > 1 ? \"s\" : \"\"} non reconnue${issue2.keys.length > 1 ? \"s\" : \"\"} : ${joinValues(issue2.keys, \", \")}`;\n case \"invalid_key\":\n return `Cl\\xE9 invalide dans ${issue2.origin}`;\n case \"invalid_union\":\n return \"Entr\\xE9e invalide\";\n case \"invalid_element\":\n return `Valeur invalide dans ${issue2.origin}`;\n default:\n return `Entr\\xE9e invalide`;\n }\n };\n };\n function fr_CA_default() {\n return {\n localeError: error15()\n };\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/he.js\n var error16 = () => {\n const TypeNames = {\n string: { label: \"\\u05DE\\u05D7\\u05E8\\u05D5\\u05D6\\u05EA\", gender: \"f\" },\n number: { label: \"\\u05DE\\u05E1\\u05E4\\u05E8\", gender: \"m\" },\n boolean: { label: \"\\u05E2\\u05E8\\u05DA \\u05D1\\u05D5\\u05DC\\u05D9\\u05D0\\u05E0\\u05D9\", gender: \"m\" },\n bigint: { label: \"BigInt\", gender: \"m\" },\n date: { label: \"\\u05EA\\u05D0\\u05E8\\u05D9\\u05DA\", gender: \"m\" },\n array: { label: \"\\u05DE\\u05E2\\u05E8\\u05DA\", gender: \"m\" },\n object: { label: \"\\u05D0\\u05D5\\u05D1\\u05D9\\u05D9\\u05E7\\u05D8\", gender: \"m\" },\n null: { label: \"\\u05E2\\u05E8\\u05DA \\u05E8\\u05D9\\u05E7 (null)\", gender: \"m\" },\n undefined: { label: \"\\u05E2\\u05E8\\u05DA \\u05DC\\u05D0 \\u05DE\\u05D5\\u05D2\\u05D3\\u05E8 (undefined)\", gender: \"m\" },\n symbol: { label: \"\\u05E1\\u05D9\\u05DE\\u05D1\\u05D5\\u05DC (Symbol)\", gender: \"m\" },\n function: { label: \"\\u05E4\\u05D5\\u05E0\\u05E7\\u05E6\\u05D9\\u05D4\", gender: \"f\" },\n map: { label: \"\\u05DE\\u05E4\\u05D4 (Map)\", gender: \"f\" },\n set: { label: \"\\u05E7\\u05D1\\u05D5\\u05E6\\u05D4 (Set)\", gender: \"f\" },\n file: { label: \"\\u05E7\\u05D5\\u05D1\\u05E5\", gender: \"m\" },\n promise: { label: \"Promise\", gender: \"m\" },\n NaN: { label: \"NaN\", gender: \"m\" },\n unknown: { label: \"\\u05E2\\u05E8\\u05DA \\u05DC\\u05D0 \\u05D9\\u05D3\\u05D5\\u05E2\", gender: \"m\" },\n value: { label: \"\\u05E2\\u05E8\\u05DA\", gender: \"m\" }\n };\n const Sizable = {\n string: { unit: \"\\u05EA\\u05D5\\u05D5\\u05D9\\u05DD\", shortLabel: \"\\u05E7\\u05E6\\u05E8\", longLabel: \"\\u05D0\\u05E8\\u05D5\\u05DA\" },\n file: { unit: \"\\u05D1\\u05D9\\u05D9\\u05D8\\u05D9\\u05DD\", shortLabel: \"\\u05E7\\u05D8\\u05DF\", longLabel: \"\\u05D2\\u05D3\\u05D5\\u05DC\" },\n array: { unit: \"\\u05E4\\u05E8\\u05D9\\u05D8\\u05D9\\u05DD\", shortLabel: \"\\u05E7\\u05D8\\u05DF\", longLabel: \"\\u05D2\\u05D3\\u05D5\\u05DC\" },\n set: { unit: \"\\u05E4\\u05E8\\u05D9\\u05D8\\u05D9\\u05DD\", shortLabel: \"\\u05E7\\u05D8\\u05DF\", longLabel: \"\\u05D2\\u05D3\\u05D5\\u05DC\" },\n number: { unit: \"\", shortLabel: \"\\u05E7\\u05D8\\u05DF\", longLabel: \"\\u05D2\\u05D3\\u05D5\\u05DC\" }\n // no unit\n };\n const typeEntry = (t) => t ? TypeNames[t] : void 0;\n const typeLabel = (t) => {\n const e = typeEntry(t);\n if (e)\n return e.label;\n return t ?? TypeNames.unknown.label;\n };\n const withDefinite = (t) => `\\u05D4${typeLabel(t)}`;\n const verbFor = (t) => {\n const e = typeEntry(t);\n const gender = e?.gender ?? \"m\";\n return gender === \"f\" ? \"\\u05E6\\u05E8\\u05D9\\u05DB\\u05D4 \\u05DC\\u05D4\\u05D9\\u05D5\\u05EA\" : \"\\u05E6\\u05E8\\u05D9\\u05DA \\u05DC\\u05D4\\u05D9\\u05D5\\u05EA\";\n };\n const getSizing = (origin) => {\n if (!origin)\n return null;\n return Sizable[origin] ?? null;\n };\n const FormatDictionary = {\n regex: { label: \"\\u05E7\\u05DC\\u05D8\", gender: \"m\" },\n email: { label: \"\\u05DB\\u05EA\\u05D5\\u05D1\\u05EA \\u05D0\\u05D9\\u05DE\\u05D9\\u05D9\\u05DC\", gender: \"f\" },\n url: { label: \"\\u05DB\\u05EA\\u05D5\\u05D1\\u05EA \\u05E8\\u05E9\\u05EA\", gender: \"f\" },\n emoji: { label: \"\\u05D0\\u05D9\\u05DE\\u05D5\\u05D2'\\u05D9\", gender: \"m\" },\n uuid: { label: \"UUID\", gender: \"m\" },\n nanoid: { label: \"nanoid\", gender: \"m\" },\n guid: { label: \"GUID\", gender: \"m\" },\n cuid: { label: \"cuid\", gender: \"m\" },\n cuid2: { label: \"cuid2\", gender: \"m\" },\n ulid: { label: \"ULID\", gender: \"m\" },\n xid: { label: \"XID\", gender: \"m\" },\n ksuid: { label: \"KSUID\", gender: \"m\" },\n datetime: { label: \"\\u05EA\\u05D0\\u05E8\\u05D9\\u05DA \\u05D5\\u05D6\\u05DE\\u05DF ISO\", gender: \"m\" },\n date: { label: \"\\u05EA\\u05D0\\u05E8\\u05D9\\u05DA ISO\", gender: \"m\" },\n time: { label: \"\\u05D6\\u05DE\\u05DF ISO\", gender: \"m\" },\n duration: { label: \"\\u05DE\\u05E9\\u05DA \\u05D6\\u05DE\\u05DF ISO\", gender: \"m\" },\n ipv4: { label: \"\\u05DB\\u05EA\\u05D5\\u05D1\\u05EA IPv4\", gender: \"f\" },\n ipv6: { label: \"\\u05DB\\u05EA\\u05D5\\u05D1\\u05EA IPv6\", gender: \"f\" },\n cidrv4: { label: \"\\u05D8\\u05D5\\u05D5\\u05D7 IPv4\", gender: \"m\" },\n cidrv6: { label: \"\\u05D8\\u05D5\\u05D5\\u05D7 IPv6\", gender: \"m\" },\n base64: { label: \"\\u05DE\\u05D7\\u05E8\\u05D5\\u05D6\\u05EA \\u05D1\\u05D1\\u05E1\\u05D9\\u05E1 64\", gender: \"f\" },\n base64url: { label: \"\\u05DE\\u05D7\\u05E8\\u05D5\\u05D6\\u05EA \\u05D1\\u05D1\\u05E1\\u05D9\\u05E1 64 \\u05DC\\u05DB\\u05EA\\u05D5\\u05D1\\u05D5\\u05EA \\u05E8\\u05E9\\u05EA\", gender: \"f\" },\n json_string: { label: \"\\u05DE\\u05D7\\u05E8\\u05D5\\u05D6\\u05EA JSON\", gender: \"f\" },\n e164: { label: \"\\u05DE\\u05E1\\u05E4\\u05E8 E.164\", gender: \"m\" },\n jwt: { label: \"JWT\", gender: \"m\" },\n ends_with: { label: \"\\u05E7\\u05DC\\u05D8\", gender: \"m\" },\n includes: { label: \"\\u05E7\\u05DC\\u05D8\", gender: \"m\" },\n lowercase: { label: \"\\u05E7\\u05DC\\u05D8\", gender: \"m\" },\n starts_with: { label: \"\\u05E7\\u05DC\\u05D8\", gender: \"m\" },\n uppercase: { label: \"\\u05E7\\u05DC\\u05D8\", gender: \"m\" }\n };\n const TypeDictionary = {\n nan: \"NaN\"\n };\n return (issue2) => {\n switch (issue2.code) {\n case \"invalid_type\": {\n const expectedKey = issue2.expected;\n const expected = TypeDictionary[expectedKey ?? \"\"] ?? typeLabel(expectedKey);\n const receivedType = parsedType(issue2.input);\n const received = TypeDictionary[receivedType] ?? TypeNames[receivedType]?.label ?? receivedType;\n if (/^[A-Z]/.test(issue2.expected)) {\n return `\\u05E7\\u05DC\\u05D8 \\u05DC\\u05D0 \\u05EA\\u05E7\\u05D9\\u05DF: \\u05E6\\u05E8\\u05D9\\u05DA \\u05DC\\u05D4\\u05D9\\u05D5\\u05EA instanceof ${issue2.expected}, \\u05D4\\u05EA\\u05E7\\u05D1\\u05DC ${received}`;\n }\n return `\\u05E7\\u05DC\\u05D8 \\u05DC\\u05D0 \\u05EA\\u05E7\\u05D9\\u05DF: \\u05E6\\u05E8\\u05D9\\u05DA \\u05DC\\u05D4\\u05D9\\u05D5\\u05EA ${expected}, \\u05D4\\u05EA\\u05E7\\u05D1\\u05DC ${received}`;\n }\n case \"invalid_value\": {\n if (issue2.values.length === 1) {\n return `\\u05E2\\u05E8\\u05DA \\u05DC\\u05D0 \\u05EA\\u05E7\\u05D9\\u05DF: \\u05D4\\u05E2\\u05E8\\u05DA \\u05D7\\u05D9\\u05D9\\u05D1 \\u05DC\\u05D4\\u05D9\\u05D5\\u05EA ${stringifyPrimitive(issue2.values[0])}`;\n }\n const stringified = issue2.values.map((v) => stringifyPrimitive(v));\n if (issue2.values.length === 2) {\n return `\\u05E2\\u05E8\\u05DA \\u05DC\\u05D0 \\u05EA\\u05E7\\u05D9\\u05DF: \\u05D4\\u05D0\\u05E4\\u05E9\\u05E8\\u05D5\\u05D9\\u05D5\\u05EA \\u05D4\\u05DE\\u05EA\\u05D0\\u05D9\\u05DE\\u05D5\\u05EA \\u05D4\\u05DF ${stringified[0]} \\u05D0\\u05D5 ${stringified[1]}`;\n }\n const lastValue = stringified[stringified.length - 1];\n const restValues = stringified.slice(0, -1).join(\", \");\n return `\\u05E2\\u05E8\\u05DA \\u05DC\\u05D0 \\u05EA\\u05E7\\u05D9\\u05DF: \\u05D4\\u05D0\\u05E4\\u05E9\\u05E8\\u05D5\\u05D9\\u05D5\\u05EA \\u05D4\\u05DE\\u05EA\\u05D0\\u05D9\\u05DE\\u05D5\\u05EA \\u05D4\\u05DF ${restValues} \\u05D0\\u05D5 ${lastValue}`;\n }\n case \"too_big\": {\n const sizing = getSizing(issue2.origin);\n const subject = withDefinite(issue2.origin ?? \"value\");\n if (issue2.origin === \"string\") {\n return `${sizing?.longLabel ?? \"\\u05D0\\u05E8\\u05D5\\u05DA\"} \\u05DE\\u05D3\\u05D9: ${subject} \\u05E6\\u05E8\\u05D9\\u05DB\\u05D4 \\u05DC\\u05D4\\u05DB\\u05D9\\u05DC ${issue2.maximum.toString()} ${sizing?.unit ?? \"\"} ${issue2.inclusive ? \"\\u05D0\\u05D5 \\u05E4\\u05D7\\u05D5\\u05EA\" : \"\\u05DC\\u05DB\\u05DC \\u05D4\\u05D9\\u05D5\\u05EA\\u05E8\"}`.trim();\n }\n if (issue2.origin === \"number\") {\n const comparison = issue2.inclusive ? `\\u05E7\\u05D8\\u05DF \\u05D0\\u05D5 \\u05E9\\u05D5\\u05D5\\u05D4 \\u05DC-${issue2.maximum}` : `\\u05E7\\u05D8\\u05DF \\u05DE-${issue2.maximum}`;\n return `\\u05D2\\u05D3\\u05D5\\u05DC \\u05DE\\u05D3\\u05D9: ${subject} \\u05E6\\u05E8\\u05D9\\u05DA \\u05DC\\u05D4\\u05D9\\u05D5\\u05EA ${comparison}`;\n }\n if (issue2.origin === \"array\" || issue2.origin === \"set\") {\n const verb = issue2.origin === \"set\" ? \"\\u05E6\\u05E8\\u05D9\\u05DB\\u05D4\" : \"\\u05E6\\u05E8\\u05D9\\u05DA\";\n const comparison = issue2.inclusive ? `${issue2.maximum} ${sizing?.unit ?? \"\"} \\u05D0\\u05D5 \\u05E4\\u05D7\\u05D5\\u05EA` : `\\u05E4\\u05D7\\u05D5\\u05EA \\u05DE-${issue2.maximum} ${sizing?.unit ?? \"\"}`;\n return `\\u05D2\\u05D3\\u05D5\\u05DC \\u05DE\\u05D3\\u05D9: ${subject} ${verb} \\u05DC\\u05D4\\u05DB\\u05D9\\u05DC ${comparison}`.trim();\n }\n const adj = issue2.inclusive ? \"<=\" : \"<\";\n const be = verbFor(issue2.origin ?? \"value\");\n if (sizing?.unit) {\n return `${sizing.longLabel} \\u05DE\\u05D3\\u05D9: ${subject} ${be} ${adj}${issue2.maximum.toString()} ${sizing.unit}`;\n }\n return `${sizing?.longLabel ?? \"\\u05D2\\u05D3\\u05D5\\u05DC\"} \\u05DE\\u05D3\\u05D9: ${subject} ${be} ${adj}${issue2.maximum.toString()}`;\n }\n case \"too_small\": {\n const sizing = getSizing(issue2.origin);\n const subject = withDefinite(issue2.origin ?? \"value\");\n if (issue2.origin === \"string\") {\n return `${sizing?.shortLabel ?? \"\\u05E7\\u05E6\\u05E8\"} \\u05DE\\u05D3\\u05D9: ${subject} \\u05E6\\u05E8\\u05D9\\u05DB\\u05D4 \\u05DC\\u05D4\\u05DB\\u05D9\\u05DC ${issue2.minimum.toString()} ${sizing?.unit ?? \"\"} ${issue2.inclusive ? \"\\u05D0\\u05D5 \\u05D9\\u05D5\\u05EA\\u05E8\" : \"\\u05DC\\u05E4\\u05D7\\u05D5\\u05EA\"}`.trim();\n }\n if (issue2.origin === \"number\") {\n const comparison = issue2.inclusive ? `\\u05D2\\u05D3\\u05D5\\u05DC \\u05D0\\u05D5 \\u05E9\\u05D5\\u05D5\\u05D4 \\u05DC-${issue2.minimum}` : `\\u05D2\\u05D3\\u05D5\\u05DC \\u05DE-${issue2.minimum}`;\n return `\\u05E7\\u05D8\\u05DF \\u05DE\\u05D3\\u05D9: ${subject} \\u05E6\\u05E8\\u05D9\\u05DA \\u05DC\\u05D4\\u05D9\\u05D5\\u05EA ${comparison}`;\n }\n if (issue2.origin === \"array\" || issue2.origin === \"set\") {\n const verb = issue2.origin === \"set\" ? \"\\u05E6\\u05E8\\u05D9\\u05DB\\u05D4\" : \"\\u05E6\\u05E8\\u05D9\\u05DA\";\n if (issue2.minimum === 1 && issue2.inclusive) {\n const singularPhrase = issue2.origin === \"set\" ? \"\\u05DC\\u05E4\\u05D7\\u05D5\\u05EA \\u05E4\\u05E8\\u05D9\\u05D8 \\u05D0\\u05D7\\u05D3\" : \"\\u05DC\\u05E4\\u05D7\\u05D5\\u05EA \\u05E4\\u05E8\\u05D9\\u05D8 \\u05D0\\u05D7\\u05D3\";\n return `\\u05E7\\u05D8\\u05DF \\u05DE\\u05D3\\u05D9: ${subject} ${verb} \\u05DC\\u05D4\\u05DB\\u05D9\\u05DC ${singularPhrase}`;\n }\n const comparison = issue2.inclusive ? `${issue2.minimum} ${sizing?.unit ?? \"\"} \\u05D0\\u05D5 \\u05D9\\u05D5\\u05EA\\u05E8` : `\\u05D9\\u05D5\\u05EA\\u05E8 \\u05DE-${issue2.minimum} ${sizing?.unit ?? \"\"}`;\n return `\\u05E7\\u05D8\\u05DF \\u05DE\\u05D3\\u05D9: ${subject} ${verb} \\u05DC\\u05D4\\u05DB\\u05D9\\u05DC ${comparison}`.trim();\n }\n const adj = issue2.inclusive ? \">=\" : \">\";\n const be = verbFor(issue2.origin ?? \"value\");\n if (sizing?.unit) {\n return `${sizing.shortLabel} \\u05DE\\u05D3\\u05D9: ${subject} ${be} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;\n }\n return `${sizing?.shortLabel ?? \"\\u05E7\\u05D8\\u05DF\"} \\u05DE\\u05D3\\u05D9: ${subject} ${be} ${adj}${issue2.minimum.toString()}`;\n }\n case \"invalid_format\": {\n const _issue = issue2;\n if (_issue.format === \"starts_with\")\n return `\\u05D4\\u05DE\\u05D7\\u05E8\\u05D5\\u05D6\\u05EA \\u05D7\\u05D9\\u05D9\\u05D1\\u05EA \\u05DC\\u05D4\\u05EA\\u05D7\\u05D9\\u05DC \\u05D1 \"${_issue.prefix}\"`;\n if (_issue.format === \"ends_with\")\n return `\\u05D4\\u05DE\\u05D7\\u05E8\\u05D5\\u05D6\\u05EA \\u05D7\\u05D9\\u05D9\\u05D1\\u05EA \\u05DC\\u05D4\\u05E1\\u05EA\\u05D9\\u05D9\\u05DD \\u05D1 \"${_issue.suffix}\"`;\n if (_issue.format === \"includes\")\n return `\\u05D4\\u05DE\\u05D7\\u05E8\\u05D5\\u05D6\\u05EA \\u05D7\\u05D9\\u05D9\\u05D1\\u05EA \\u05DC\\u05DB\\u05DC\\u05D5\\u05DC \"${_issue.includes}\"`;\n if (_issue.format === \"regex\")\n return `\\u05D4\\u05DE\\u05D7\\u05E8\\u05D5\\u05D6\\u05EA \\u05D7\\u05D9\\u05D9\\u05D1\\u05EA \\u05DC\\u05D4\\u05EA\\u05D0\\u05D9\\u05DD \\u05DC\\u05EA\\u05D1\\u05E0\\u05D9\\u05EA ${_issue.pattern}`;\n const nounEntry = FormatDictionary[_issue.format];\n const noun = nounEntry?.label ?? _issue.format;\n const gender = nounEntry?.gender ?? \"m\";\n const adjective = gender === \"f\" ? \"\\u05EA\\u05E7\\u05D9\\u05E0\\u05D4\" : \"\\u05EA\\u05E7\\u05D9\\u05DF\";\n return `${noun} \\u05DC\\u05D0 ${adjective}`;\n }\n case \"not_multiple_of\":\n return `\\u05DE\\u05E1\\u05E4\\u05E8 \\u05DC\\u05D0 \\u05EA\\u05E7\\u05D9\\u05DF: \\u05D7\\u05D9\\u05D9\\u05D1 \\u05DC\\u05D4\\u05D9\\u05D5\\u05EA \\u05DE\\u05DB\\u05E4\\u05DC\\u05D4 \\u05E9\\u05DC ${issue2.divisor}`;\n case \"unrecognized_keys\":\n return `\\u05DE\\u05E4\\u05EA\\u05D7${issue2.keys.length > 1 ? \"\\u05D5\\u05EA\" : \"\"} \\u05DC\\u05D0 \\u05DE\\u05D6\\u05D5\\u05D4${issue2.keys.length > 1 ? \"\\u05D9\\u05DD\" : \"\\u05D4\"}: ${joinValues(issue2.keys, \", \")}`;\n case \"invalid_key\": {\n return `\\u05E9\\u05D3\\u05D4 \\u05DC\\u05D0 \\u05EA\\u05E7\\u05D9\\u05DF \\u05D1\\u05D0\\u05D5\\u05D1\\u05D9\\u05D9\\u05E7\\u05D8`;\n }\n case \"invalid_union\":\n return \"\\u05E7\\u05DC\\u05D8 \\u05DC\\u05D0 \\u05EA\\u05E7\\u05D9\\u05DF\";\n case \"invalid_element\": {\n const place = withDefinite(issue2.origin ?? \"array\");\n return `\\u05E2\\u05E8\\u05DA \\u05DC\\u05D0 \\u05EA\\u05E7\\u05D9\\u05DF \\u05D1${place}`;\n }\n default:\n return `\\u05E7\\u05DC\\u05D8 \\u05DC\\u05D0 \\u05EA\\u05E7\\u05D9\\u05DF`;\n }\n };\n };\n function he_default() {\n return {\n localeError: error16()\n };\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/hu.js\n var error17 = () => {\n const Sizable = {\n string: { unit: \"karakter\", verb: \"legyen\" },\n file: { unit: \"byte\", verb: \"legyen\" },\n array: { unit: \"elem\", verb: \"legyen\" },\n set: { unit: \"elem\", verb: \"legyen\" }\n };\n function getSizing(origin) {\n return Sizable[origin] ?? null;\n }\n const FormatDictionary = {\n regex: \"bemenet\",\n email: \"email c\\xEDm\",\n url: \"URL\",\n emoji: \"emoji\",\n uuid: \"UUID\",\n uuidv4: \"UUIDv4\",\n uuidv6: \"UUIDv6\",\n nanoid: \"nanoid\",\n guid: \"GUID\",\n cuid: \"cuid\",\n cuid2: \"cuid2\",\n ulid: \"ULID\",\n xid: \"XID\",\n ksuid: \"KSUID\",\n datetime: \"ISO id\\u0151b\\xE9lyeg\",\n date: \"ISO d\\xE1tum\",\n time: \"ISO id\\u0151\",\n duration: \"ISO id\\u0151intervallum\",\n ipv4: \"IPv4 c\\xEDm\",\n ipv6: \"IPv6 c\\xEDm\",\n cidrv4: \"IPv4 tartom\\xE1ny\",\n cidrv6: \"IPv6 tartom\\xE1ny\",\n base64: \"base64-k\\xF3dolt string\",\n base64url: \"base64url-k\\xF3dolt string\",\n json_string: \"JSON string\",\n e164: \"E.164 sz\\xE1m\",\n jwt: \"JWT\",\n template_literal: \"bemenet\"\n };\n const TypeDictionary = {\n nan: \"NaN\",\n number: \"sz\\xE1m\",\n array: \"t\\xF6mb\"\n };\n return (issue2) => {\n switch (issue2.code) {\n case \"invalid_type\": {\n const expected = TypeDictionary[issue2.expected] ?? issue2.expected;\n const receivedType = parsedType(issue2.input);\n const received = TypeDictionary[receivedType] ?? receivedType;\n if (/^[A-Z]/.test(issue2.expected)) {\n return `\\xC9rv\\xE9nytelen bemenet: a v\\xE1rt \\xE9rt\\xE9k instanceof ${issue2.expected}, a kapott \\xE9rt\\xE9k ${received}`;\n }\n return `\\xC9rv\\xE9nytelen bemenet: a v\\xE1rt \\xE9rt\\xE9k ${expected}, a kapott \\xE9rt\\xE9k ${received}`;\n }\n case \"invalid_value\":\n if (issue2.values.length === 1)\n return `\\xC9rv\\xE9nytelen bemenet: a v\\xE1rt \\xE9rt\\xE9k ${stringifyPrimitive(issue2.values[0])}`;\n return `\\xC9rv\\xE9nytelen opci\\xF3: valamelyik \\xE9rt\\xE9k v\\xE1rt ${joinValues(issue2.values, \"|\")}`;\n case \"too_big\": {\n const adj = issue2.inclusive ? \"<=\" : \"<\";\n const sizing = getSizing(issue2.origin);\n if (sizing)\n return `T\\xFAl nagy: ${issue2.origin ?? \"\\xE9rt\\xE9k\"} m\\xE9rete t\\xFAl nagy ${adj}${issue2.maximum.toString()} ${sizing.unit ?? \"elem\"}`;\n return `T\\xFAl nagy: a bemeneti \\xE9rt\\xE9k ${issue2.origin ?? \"\\xE9rt\\xE9k\"} t\\xFAl nagy: ${adj}${issue2.maximum.toString()}`;\n }\n case \"too_small\": {\n const adj = issue2.inclusive ? \">=\" : \">\";\n const sizing = getSizing(issue2.origin);\n if (sizing) {\n return `T\\xFAl kicsi: a bemeneti \\xE9rt\\xE9k ${issue2.origin} m\\xE9rete t\\xFAl kicsi ${adj}${issue2.minimum.toString()} ${sizing.unit}`;\n }\n return `T\\xFAl kicsi: a bemeneti \\xE9rt\\xE9k ${issue2.origin} t\\xFAl kicsi ${adj}${issue2.minimum.toString()}`;\n }\n case \"invalid_format\": {\n const _issue = issue2;\n if (_issue.format === \"starts_with\")\n return `\\xC9rv\\xE9nytelen string: \"${_issue.prefix}\" \\xE9rt\\xE9kkel kell kezd\\u0151dnie`;\n if (_issue.format === \"ends_with\")\n return `\\xC9rv\\xE9nytelen string: \"${_issue.suffix}\" \\xE9rt\\xE9kkel kell v\\xE9gz\\u0151dnie`;\n if (_issue.format === \"includes\")\n return `\\xC9rv\\xE9nytelen string: \"${_issue.includes}\" \\xE9rt\\xE9ket kell tartalmaznia`;\n if (_issue.format === \"regex\")\n return `\\xC9rv\\xE9nytelen string: ${_issue.pattern} mint\\xE1nak kell megfelelnie`;\n return `\\xC9rv\\xE9nytelen ${FormatDictionary[_issue.format] ?? issue2.format}`;\n }\n case \"not_multiple_of\":\n return `\\xC9rv\\xE9nytelen sz\\xE1m: ${issue2.divisor} t\\xF6bbsz\\xF6r\\xF6s\\xE9nek kell lennie`;\n case \"unrecognized_keys\":\n return `Ismeretlen kulcs${issue2.keys.length > 1 ? \"s\" : \"\"}: ${joinValues(issue2.keys, \", \")}`;\n case \"invalid_key\":\n return `\\xC9rv\\xE9nytelen kulcs ${issue2.origin}`;\n case \"invalid_union\":\n return \"\\xC9rv\\xE9nytelen bemenet\";\n case \"invalid_element\":\n return `\\xC9rv\\xE9nytelen \\xE9rt\\xE9k: ${issue2.origin}`;\n default:\n return `\\xC9rv\\xE9nytelen bemenet`;\n }\n };\n };\n function hu_default() {\n return {\n localeError: error17()\n };\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/hy.js\n function getArmenianPlural(count, one, many) {\n return Math.abs(count) === 1 ? one : many;\n }\n function withDefiniteArticle(word) {\n if (!word)\n return \"\";\n const vowels = [\"\\u0561\", \"\\u0565\", \"\\u0568\", \"\\u056B\", \"\\u0578\", \"\\u0578\\u0582\", \"\\u0585\"];\n const lastChar = word[word.length - 1];\n return word + (vowels.includes(lastChar) ? \"\\u0576\" : \"\\u0568\");\n }\n var error18 = () => {\n const Sizable = {\n string: {\n unit: {\n one: \"\\u0576\\u0577\\u0561\\u0576\",\n many: \"\\u0576\\u0577\\u0561\\u0576\\u0576\\u0565\\u0580\"\n },\n verb: \"\\u0578\\u0582\\u0576\\u0565\\u0576\\u0561\\u056C\"\n },\n file: {\n unit: {\n one: \"\\u0562\\u0561\\u0575\\u0569\",\n many: \"\\u0562\\u0561\\u0575\\u0569\\u0565\\u0580\"\n },\n verb: \"\\u0578\\u0582\\u0576\\u0565\\u0576\\u0561\\u056C\"\n },\n array: {\n unit: {\n one: \"\\u057F\\u0561\\u0580\\u0580\",\n many: \"\\u057F\\u0561\\u0580\\u0580\\u0565\\u0580\"\n },\n verb: \"\\u0578\\u0582\\u0576\\u0565\\u0576\\u0561\\u056C\"\n },\n set: {\n unit: {\n one: \"\\u057F\\u0561\\u0580\\u0580\",\n many: \"\\u057F\\u0561\\u0580\\u0580\\u0565\\u0580\"\n },\n verb: \"\\u0578\\u0582\\u0576\\u0565\\u0576\\u0561\\u056C\"\n }\n };\n function getSizing(origin) {\n return Sizable[origin] ?? null;\n }\n const FormatDictionary = {\n regex: \"\\u0574\\u0578\\u0582\\u057F\\u0584\",\n email: \"\\u0567\\u056C. \\u0570\\u0561\\u057D\\u0581\\u0565\",\n url: \"URL\",\n emoji: \"\\u0567\\u0574\\u0578\\u057B\\u056B\",\n uuid: \"UUID\",\n uuidv4: \"UUIDv4\",\n uuidv6: \"UUIDv6\",\n nanoid: \"nanoid\",\n guid: \"GUID\",\n cuid: \"cuid\",\n cuid2: \"cuid2\",\n ulid: \"ULID\",\n xid: \"XID\",\n ksuid: \"KSUID\",\n datetime: \"ISO \\u0561\\u0574\\u057D\\u0561\\u0569\\u056B\\u057E \\u0587 \\u056A\\u0561\\u0574\",\n date: \"ISO \\u0561\\u0574\\u057D\\u0561\\u0569\\u056B\\u057E\",\n time: \"ISO \\u056A\\u0561\\u0574\",\n duration: \"ISO \\u057F\\u0587\\u0578\\u0572\\u0578\\u0582\\u0569\\u0575\\u0578\\u0582\\u0576\",\n ipv4: \"IPv4 \\u0570\\u0561\\u057D\\u0581\\u0565\",\n ipv6: \"IPv6 \\u0570\\u0561\\u057D\\u0581\\u0565\",\n cidrv4: \"IPv4 \\u0574\\u056B\\u057B\\u0561\\u056F\\u0561\\u0575\\u0584\",\n cidrv6: \"IPv6 \\u0574\\u056B\\u057B\\u0561\\u056F\\u0561\\u0575\\u0584\",\n base64: \"base64 \\u0571\\u0587\\u0561\\u0579\\u0561\\u0583\\u0578\\u057E \\u057F\\u0578\\u0572\",\n base64url: \"base64url \\u0571\\u0587\\u0561\\u0579\\u0561\\u0583\\u0578\\u057E \\u057F\\u0578\\u0572\",\n json_string: \"JSON \\u057F\\u0578\\u0572\",\n e164: \"E.164 \\u0570\\u0561\\u0574\\u0561\\u0580\",\n jwt: \"JWT\",\n template_literal: \"\\u0574\\u0578\\u0582\\u057F\\u0584\"\n };\n const TypeDictionary = {\n nan: \"NaN\",\n number: \"\\u0569\\u056B\\u057E\",\n array: \"\\u0566\\u0561\\u0576\\u0563\\u057E\\u0561\\u056E\"\n };\n return (issue2) => {\n switch (issue2.code) {\n case \"invalid_type\": {\n const expected = TypeDictionary[issue2.expected] ?? issue2.expected;\n const receivedType = parsedType(issue2.input);\n const received = TypeDictionary[receivedType] ?? receivedType;\n if (/^[A-Z]/.test(issue2.expected)) {\n return `\\u054D\\u056D\\u0561\\u056C \\u0574\\u0578\\u0582\\u057F\\u0584\\u0561\\u0563\\u0580\\u0578\\u0582\\u0574\\u2024 \\u057D\\u057A\\u0561\\u057D\\u057E\\u0578\\u0582\\u0574 \\u0567\\u0580 instanceof ${issue2.expected}, \\u057D\\u057F\\u0561\\u0581\\u057E\\u0565\\u056C \\u0567 ${received}`;\n }\n return `\\u054D\\u056D\\u0561\\u056C \\u0574\\u0578\\u0582\\u057F\\u0584\\u0561\\u0563\\u0580\\u0578\\u0582\\u0574\\u2024 \\u057D\\u057A\\u0561\\u057D\\u057E\\u0578\\u0582\\u0574 \\u0567\\u0580 ${expected}, \\u057D\\u057F\\u0561\\u0581\\u057E\\u0565\\u056C \\u0567 ${received}`;\n }\n case \"invalid_value\":\n if (issue2.values.length === 1)\n return `\\u054D\\u056D\\u0561\\u056C \\u0574\\u0578\\u0582\\u057F\\u0584\\u0561\\u0563\\u0580\\u0578\\u0582\\u0574\\u2024 \\u057D\\u057A\\u0561\\u057D\\u057E\\u0578\\u0582\\u0574 \\u0567\\u0580 ${stringifyPrimitive(issue2.values[1])}`;\n return `\\u054D\\u056D\\u0561\\u056C \\u057F\\u0561\\u0580\\u0562\\u0565\\u0580\\u0561\\u056F\\u2024 \\u057D\\u057A\\u0561\\u057D\\u057E\\u0578\\u0582\\u0574 \\u0567\\u0580 \\u0570\\u0565\\u057F\\u0587\\u0575\\u0561\\u056C\\u0576\\u0565\\u0580\\u056B\\u0581 \\u0574\\u0565\\u056F\\u0568\\u055D ${joinValues(issue2.values, \"|\")}`;\n case \"too_big\": {\n const adj = issue2.inclusive ? \"<=\" : \"<\";\n const sizing = getSizing(issue2.origin);\n if (sizing) {\n const maxValue = Number(issue2.maximum);\n const unit = getArmenianPlural(maxValue, sizing.unit.one, sizing.unit.many);\n return `\\u0549\\u0561\\u0583\\u0561\\u0566\\u0561\\u0576\\u0581 \\u0574\\u0565\\u056E \\u0561\\u0580\\u056A\\u0565\\u0584\\u2024 \\u057D\\u057A\\u0561\\u057D\\u057E\\u0578\\u0582\\u0574 \\u0567, \\u0578\\u0580 ${withDefiniteArticle(issue2.origin ?? \"\\u0561\\u0580\\u056A\\u0565\\u0584\")} \\u056F\\u0578\\u0582\\u0576\\u0565\\u0576\\u0561 ${adj}${issue2.maximum.toString()} ${unit}`;\n }\n return `\\u0549\\u0561\\u0583\\u0561\\u0566\\u0561\\u0576\\u0581 \\u0574\\u0565\\u056E \\u0561\\u0580\\u056A\\u0565\\u0584\\u2024 \\u057D\\u057A\\u0561\\u057D\\u057E\\u0578\\u0582\\u0574 \\u0567, \\u0578\\u0580 ${withDefiniteArticle(issue2.origin ?? \"\\u0561\\u0580\\u056A\\u0565\\u0584\")} \\u056C\\u056B\\u0576\\u056B ${adj}${issue2.maximum.toString()}`;\n }\n case \"too_small\": {\n const adj = issue2.inclusive ? \">=\" : \">\";\n const sizing = getSizing(issue2.origin);\n if (sizing) {\n const minValue = Number(issue2.minimum);\n const unit = getArmenianPlural(minValue, sizing.unit.one, sizing.unit.many);\n return `\\u0549\\u0561\\u0583\\u0561\\u0566\\u0561\\u0576\\u0581 \\u0583\\u0578\\u0584\\u0580 \\u0561\\u0580\\u056A\\u0565\\u0584\\u2024 \\u057D\\u057A\\u0561\\u057D\\u057E\\u0578\\u0582\\u0574 \\u0567, \\u0578\\u0580 ${withDefiniteArticle(issue2.origin)} \\u056F\\u0578\\u0582\\u0576\\u0565\\u0576\\u0561 ${adj}${issue2.minimum.toString()} ${unit}`;\n }\n return `\\u0549\\u0561\\u0583\\u0561\\u0566\\u0561\\u0576\\u0581 \\u0583\\u0578\\u0584\\u0580 \\u0561\\u0580\\u056A\\u0565\\u0584\\u2024 \\u057D\\u057A\\u0561\\u057D\\u057E\\u0578\\u0582\\u0574 \\u0567, \\u0578\\u0580 ${withDefiniteArticle(issue2.origin)} \\u056C\\u056B\\u0576\\u056B ${adj}${issue2.minimum.toString()}`;\n }\n case \"invalid_format\": {\n const _issue = issue2;\n if (_issue.format === \"starts_with\")\n return `\\u054D\\u056D\\u0561\\u056C \\u057F\\u0578\\u0572\\u2024 \\u057A\\u0565\\u057F\\u0584 \\u0567 \\u057D\\u056F\\u057D\\u057E\\u056B \"${_issue.prefix}\"-\\u0578\\u057E`;\n if (_issue.format === \"ends_with\")\n return `\\u054D\\u056D\\u0561\\u056C \\u057F\\u0578\\u0572\\u2024 \\u057A\\u0565\\u057F\\u0584 \\u0567 \\u0561\\u057E\\u0561\\u0580\\u057F\\u057E\\u056B \"${_issue.suffix}\"-\\u0578\\u057E`;\n if (_issue.format === \"includes\")\n return `\\u054D\\u056D\\u0561\\u056C \\u057F\\u0578\\u0572\\u2024 \\u057A\\u0565\\u057F\\u0584 \\u0567 \\u057A\\u0561\\u0580\\u0578\\u0582\\u0576\\u0561\\u056F\\u056B \"${_issue.includes}\"`;\n if (_issue.format === \"regex\")\n return `\\u054D\\u056D\\u0561\\u056C \\u057F\\u0578\\u0572\\u2024 \\u057A\\u0565\\u057F\\u0584 \\u0567 \\u0570\\u0561\\u0574\\u0561\\u057A\\u0561\\u057F\\u0561\\u057D\\u056D\\u0561\\u0576\\u056B ${_issue.pattern} \\u0571\\u0587\\u0561\\u0579\\u0561\\u0583\\u056B\\u0576`;\n return `\\u054D\\u056D\\u0561\\u056C ${FormatDictionary[_issue.format] ?? issue2.format}`;\n }\n case \"not_multiple_of\":\n return `\\u054D\\u056D\\u0561\\u056C \\u0569\\u056B\\u057E\\u2024 \\u057A\\u0565\\u057F\\u0584 \\u0567 \\u0562\\u0561\\u0566\\u0574\\u0561\\u057A\\u0561\\u057F\\u056B\\u056F \\u056C\\u056B\\u0576\\u056B ${issue2.divisor}-\\u056B`;\n case \"unrecognized_keys\":\n return `\\u0549\\u0573\\u0561\\u0576\\u0561\\u0579\\u057E\\u0561\\u056E \\u0562\\u0561\\u0576\\u0561\\u056C\\u056B${issue2.keys.length > 1 ? \"\\u0576\\u0565\\u0580\" : \"\"}. ${joinValues(issue2.keys, \", \")}`;\n case \"invalid_key\":\n return `\\u054D\\u056D\\u0561\\u056C \\u0562\\u0561\\u0576\\u0561\\u056C\\u056B ${withDefiniteArticle(issue2.origin)}-\\u0578\\u0582\\u0574`;\n case \"invalid_union\":\n return \"\\u054D\\u056D\\u0561\\u056C \\u0574\\u0578\\u0582\\u057F\\u0584\\u0561\\u0563\\u0580\\u0578\\u0582\\u0574\";\n case \"invalid_element\":\n return `\\u054D\\u056D\\u0561\\u056C \\u0561\\u0580\\u056A\\u0565\\u0584 ${withDefiniteArticle(issue2.origin)}-\\u0578\\u0582\\u0574`;\n default:\n return `\\u054D\\u056D\\u0561\\u056C \\u0574\\u0578\\u0582\\u057F\\u0584\\u0561\\u0563\\u0580\\u0578\\u0582\\u0574`;\n }\n };\n };\n function hy_default() {\n return {\n localeError: error18()\n };\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/id.js\n var error19 = () => {\n const Sizable = {\n string: { unit: \"karakter\", verb: \"memiliki\" },\n file: { unit: \"byte\", verb: \"memiliki\" },\n array: { unit: \"item\", verb: \"memiliki\" },\n set: { unit: \"item\", verb: \"memiliki\" }\n };\n function getSizing(origin) {\n return Sizable[origin] ?? null;\n }\n const FormatDictionary = {\n regex: \"input\",\n email: \"alamat email\",\n url: \"URL\",\n emoji: \"emoji\",\n uuid: \"UUID\",\n uuidv4: \"UUIDv4\",\n uuidv6: \"UUIDv6\",\n nanoid: \"nanoid\",\n guid: \"GUID\",\n cuid: \"cuid\",\n cuid2: \"cuid2\",\n ulid: \"ULID\",\n xid: \"XID\",\n ksuid: \"KSUID\",\n datetime: \"tanggal dan waktu format ISO\",\n date: \"tanggal format ISO\",\n time: \"jam format ISO\",\n duration: \"durasi format ISO\",\n ipv4: \"alamat IPv4\",\n ipv6: \"alamat IPv6\",\n cidrv4: \"rentang alamat IPv4\",\n cidrv6: \"rentang alamat IPv6\",\n base64: \"string dengan enkode base64\",\n base64url: \"string dengan enkode base64url\",\n json_string: \"string JSON\",\n e164: \"angka E.164\",\n jwt: \"JWT\",\n template_literal: \"input\"\n };\n const TypeDictionary = {\n nan: \"NaN\"\n };\n return (issue2) => {\n switch (issue2.code) {\n case \"invalid_type\": {\n const expected = TypeDictionary[issue2.expected] ?? issue2.expected;\n const receivedType = parsedType(issue2.input);\n const received = TypeDictionary[receivedType] ?? receivedType;\n if (/^[A-Z]/.test(issue2.expected)) {\n return `Input tidak valid: diharapkan instanceof ${issue2.expected}, diterima ${received}`;\n }\n return `Input tidak valid: diharapkan ${expected}, diterima ${received}`;\n }\n case \"invalid_value\":\n if (issue2.values.length === 1)\n return `Input tidak valid: diharapkan ${stringifyPrimitive(issue2.values[0])}`;\n return `Pilihan tidak valid: diharapkan salah satu dari ${joinValues(issue2.values, \"|\")}`;\n case \"too_big\": {\n const adj = issue2.inclusive ? \"<=\" : \"<\";\n const sizing = getSizing(issue2.origin);\n if (sizing)\n return `Terlalu besar: diharapkan ${issue2.origin ?? \"value\"} memiliki ${adj}${issue2.maximum.toString()} ${sizing.unit ?? \"elemen\"}`;\n return `Terlalu besar: diharapkan ${issue2.origin ?? \"value\"} menjadi ${adj}${issue2.maximum.toString()}`;\n }\n case \"too_small\": {\n const adj = issue2.inclusive ? \">=\" : \">\";\n const sizing = getSizing(issue2.origin);\n if (sizing) {\n return `Terlalu kecil: diharapkan ${issue2.origin} memiliki ${adj}${issue2.minimum.toString()} ${sizing.unit}`;\n }\n return `Terlalu kecil: diharapkan ${issue2.origin} menjadi ${adj}${issue2.minimum.toString()}`;\n }\n case \"invalid_format\": {\n const _issue = issue2;\n if (_issue.format === \"starts_with\")\n return `String tidak valid: harus dimulai dengan \"${_issue.prefix}\"`;\n if (_issue.format === \"ends_with\")\n return `String tidak valid: harus berakhir dengan \"${_issue.suffix}\"`;\n if (_issue.format === \"includes\")\n return `String tidak valid: harus menyertakan \"${_issue.includes}\"`;\n if (_issue.format === \"regex\")\n return `String tidak valid: harus sesuai pola ${_issue.pattern}`;\n return `${FormatDictionary[_issue.format] ?? issue2.format} tidak valid`;\n }\n case \"not_multiple_of\":\n return `Angka tidak valid: harus kelipatan dari ${issue2.divisor}`;\n case \"unrecognized_keys\":\n return `Kunci tidak dikenali ${issue2.keys.length > 1 ? \"s\" : \"\"}: ${joinValues(issue2.keys, \", \")}`;\n case \"invalid_key\":\n return `Kunci tidak valid di ${issue2.origin}`;\n case \"invalid_union\":\n return \"Input tidak valid\";\n case \"invalid_element\":\n return `Nilai tidak valid di ${issue2.origin}`;\n default:\n return `Input tidak valid`;\n }\n };\n };\n function id_default() {\n return {\n localeError: error19()\n };\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/is.js\n var error20 = () => {\n const Sizable = {\n string: { unit: \"stafi\", verb: \"a\\xF0 hafa\" },\n file: { unit: \"b\\xE6ti\", verb: \"a\\xF0 hafa\" },\n array: { unit: \"hluti\", verb: \"a\\xF0 hafa\" },\n set: { unit: \"hluti\", verb: \"a\\xF0 hafa\" }\n };\n function getSizing(origin) {\n return Sizable[origin] ?? null;\n }\n const FormatDictionary = {\n regex: \"gildi\",\n email: \"netfang\",\n url: \"vefsl\\xF3\\xF0\",\n emoji: \"emoji\",\n uuid: \"UUID\",\n uuidv4: \"UUIDv4\",\n uuidv6: \"UUIDv6\",\n nanoid: \"nanoid\",\n guid: \"GUID\",\n cuid: \"cuid\",\n cuid2: \"cuid2\",\n ulid: \"ULID\",\n xid: \"XID\",\n ksuid: \"KSUID\",\n datetime: \"ISO dagsetning og t\\xEDmi\",\n date: \"ISO dagsetning\",\n time: \"ISO t\\xEDmi\",\n duration: \"ISO t\\xEDmalengd\",\n ipv4: \"IPv4 address\",\n ipv6: \"IPv6 address\",\n cidrv4: \"IPv4 range\",\n cidrv6: \"IPv6 range\",\n base64: \"base64-encoded strengur\",\n base64url: \"base64url-encoded strengur\",\n json_string: \"JSON strengur\",\n e164: \"E.164 t\\xF6lugildi\",\n jwt: \"JWT\",\n template_literal: \"gildi\"\n };\n const TypeDictionary = {\n nan: \"NaN\",\n number: \"n\\xFAmer\",\n array: \"fylki\"\n };\n return (issue2) => {\n switch (issue2.code) {\n case \"invalid_type\": {\n const expected = TypeDictionary[issue2.expected] ?? issue2.expected;\n const receivedType = parsedType(issue2.input);\n const received = TypeDictionary[receivedType] ?? receivedType;\n if (/^[A-Z]/.test(issue2.expected)) {\n return `Rangt gildi: \\xDE\\xFA sl\\xF3st inn ${received} \\xFEar sem \\xE1 a\\xF0 vera instanceof ${issue2.expected}`;\n }\n return `Rangt gildi: \\xDE\\xFA sl\\xF3st inn ${received} \\xFEar sem \\xE1 a\\xF0 vera ${expected}`;\n }\n case \"invalid_value\":\n if (issue2.values.length === 1)\n return `Rangt gildi: gert r\\xE1\\xF0 fyrir ${stringifyPrimitive(issue2.values[0])}`;\n return `\\xD3gilt val: m\\xE1 vera eitt af eftirfarandi ${joinValues(issue2.values, \"|\")}`;\n case \"too_big\": {\n const adj = issue2.inclusive ? \"<=\" : \"<\";\n const sizing = getSizing(issue2.origin);\n if (sizing)\n return `Of st\\xF3rt: gert er r\\xE1\\xF0 fyrir a\\xF0 ${issue2.origin ?? \"gildi\"} hafi ${adj}${issue2.maximum.toString()} ${sizing.unit ?? \"hluti\"}`;\n return `Of st\\xF3rt: gert er r\\xE1\\xF0 fyrir a\\xF0 ${issue2.origin ?? \"gildi\"} s\\xE9 ${adj}${issue2.maximum.toString()}`;\n }\n case \"too_small\": {\n const adj = issue2.inclusive ? \">=\" : \">\";\n const sizing = getSizing(issue2.origin);\n if (sizing) {\n return `Of l\\xEDti\\xF0: gert er r\\xE1\\xF0 fyrir a\\xF0 ${issue2.origin} hafi ${adj}${issue2.minimum.toString()} ${sizing.unit}`;\n }\n return `Of l\\xEDti\\xF0: gert er r\\xE1\\xF0 fyrir a\\xF0 ${issue2.origin} s\\xE9 ${adj}${issue2.minimum.toString()}`;\n }\n case \"invalid_format\": {\n const _issue = issue2;\n if (_issue.format === \"starts_with\") {\n return `\\xD3gildur strengur: ver\\xF0ur a\\xF0 byrja \\xE1 \"${_issue.prefix}\"`;\n }\n if (_issue.format === \"ends_with\")\n return `\\xD3gildur strengur: ver\\xF0ur a\\xF0 enda \\xE1 \"${_issue.suffix}\"`;\n if (_issue.format === \"includes\")\n return `\\xD3gildur strengur: ver\\xF0ur a\\xF0 innihalda \"${_issue.includes}\"`;\n if (_issue.format === \"regex\")\n return `\\xD3gildur strengur: ver\\xF0ur a\\xF0 fylgja mynstri ${_issue.pattern}`;\n return `Rangt ${FormatDictionary[_issue.format] ?? issue2.format}`;\n }\n case \"not_multiple_of\":\n return `R\\xF6ng tala: ver\\xF0ur a\\xF0 vera margfeldi af ${issue2.divisor}`;\n case \"unrecognized_keys\":\n return `\\xD3\\xFEekkt ${issue2.keys.length > 1 ? \"ir lyklar\" : \"ur lykill\"}: ${joinValues(issue2.keys, \", \")}`;\n case \"invalid_key\":\n return `Rangur lykill \\xED ${issue2.origin}`;\n case \"invalid_union\":\n return \"Rangt gildi\";\n case \"invalid_element\":\n return `Rangt gildi \\xED ${issue2.origin}`;\n default:\n return `Rangt gildi`;\n }\n };\n };\n function is_default() {\n return {\n localeError: error20()\n };\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/it.js\n var error21 = () => {\n const Sizable = {\n string: { unit: \"caratteri\", verb: \"avere\" },\n file: { unit: \"byte\", verb: \"avere\" },\n array: { unit: \"elementi\", verb: \"avere\" },\n set: { unit: \"elementi\", verb: \"avere\" }\n };\n function getSizing(origin) {\n return Sizable[origin] ?? null;\n }\n const FormatDictionary = {\n regex: \"input\",\n email: \"indirizzo email\",\n url: \"URL\",\n emoji: \"emoji\",\n uuid: \"UUID\",\n uuidv4: \"UUIDv4\",\n uuidv6: \"UUIDv6\",\n nanoid: \"nanoid\",\n guid: \"GUID\",\n cuid: \"cuid\",\n cuid2: \"cuid2\",\n ulid: \"ULID\",\n xid: \"XID\",\n ksuid: \"KSUID\",\n datetime: \"data e ora ISO\",\n date: \"data ISO\",\n time: \"ora ISO\",\n duration: \"durata ISO\",\n ipv4: \"indirizzo IPv4\",\n ipv6: \"indirizzo IPv6\",\n cidrv4: \"intervallo IPv4\",\n cidrv6: \"intervallo IPv6\",\n base64: \"stringa codificata in base64\",\n base64url: \"URL codificata in base64\",\n json_string: \"stringa JSON\",\n e164: \"numero E.164\",\n jwt: \"JWT\",\n template_literal: \"input\"\n };\n const TypeDictionary = {\n nan: \"NaN\",\n number: \"numero\",\n array: \"vettore\"\n };\n return (issue2) => {\n switch (issue2.code) {\n case \"invalid_type\": {\n const expected = TypeDictionary[issue2.expected] ?? issue2.expected;\n const receivedType = parsedType(issue2.input);\n const received = TypeDictionary[receivedType] ?? receivedType;\n if (/^[A-Z]/.test(issue2.expected)) {\n return `Input non valido: atteso instanceof ${issue2.expected}, ricevuto ${received}`;\n }\n return `Input non valido: atteso ${expected}, ricevuto ${received}`;\n }\n case \"invalid_value\":\n if (issue2.values.length === 1)\n return `Input non valido: atteso ${stringifyPrimitive(issue2.values[0])}`;\n return `Opzione non valida: atteso uno tra ${joinValues(issue2.values, \"|\")}`;\n case \"too_big\": {\n const adj = issue2.inclusive ? \"<=\" : \"<\";\n const sizing = getSizing(issue2.origin);\n if (sizing)\n return `Troppo grande: ${issue2.origin ?? \"valore\"} deve avere ${adj}${issue2.maximum.toString()} ${sizing.unit ?? \"elementi\"}`;\n return `Troppo grande: ${issue2.origin ?? \"valore\"} deve essere ${adj}${issue2.maximum.toString()}`;\n }\n case \"too_small\": {\n const adj = issue2.inclusive ? \">=\" : \">\";\n const sizing = getSizing(issue2.origin);\n if (sizing) {\n return `Troppo piccolo: ${issue2.origin} deve avere ${adj}${issue2.minimum.toString()} ${sizing.unit}`;\n }\n return `Troppo piccolo: ${issue2.origin} deve essere ${adj}${issue2.minimum.toString()}`;\n }\n case \"invalid_format\": {\n const _issue = issue2;\n if (_issue.format === \"starts_with\")\n return `Stringa non valida: deve iniziare con \"${_issue.prefix}\"`;\n if (_issue.format === \"ends_with\")\n return `Stringa non valida: deve terminare con \"${_issue.suffix}\"`;\n if (_issue.format === \"includes\")\n return `Stringa non valida: deve includere \"${_issue.includes}\"`;\n if (_issue.format === \"regex\")\n return `Stringa non valida: deve corrispondere al pattern ${_issue.pattern}`;\n return `Invalid ${FormatDictionary[_issue.format] ?? issue2.format}`;\n }\n case \"not_multiple_of\":\n return `Numero non valido: deve essere un multiplo di ${issue2.divisor}`;\n case \"unrecognized_keys\":\n return `Chiav${issue2.keys.length > 1 ? \"i\" : \"e\"} non riconosciut${issue2.keys.length > 1 ? \"e\" : \"a\"}: ${joinValues(issue2.keys, \", \")}`;\n case \"invalid_key\":\n return `Chiave non valida in ${issue2.origin}`;\n case \"invalid_union\":\n return \"Input non valido\";\n case \"invalid_element\":\n return `Valore non valido in ${issue2.origin}`;\n default:\n return `Input non valido`;\n }\n };\n };\n function it_default() {\n return {\n localeError: error21()\n };\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/ja.js\n var error22 = () => {\n const Sizable = {\n string: { unit: \"\\u6587\\u5B57\", verb: \"\\u3067\\u3042\\u308B\" },\n file: { unit: \"\\u30D0\\u30A4\\u30C8\", verb: \"\\u3067\\u3042\\u308B\" },\n array: { unit: \"\\u8981\\u7D20\", verb: \"\\u3067\\u3042\\u308B\" },\n set: { unit: \"\\u8981\\u7D20\", verb: \"\\u3067\\u3042\\u308B\" }\n };\n function getSizing(origin) {\n return Sizable[origin] ?? null;\n }\n const FormatDictionary = {\n regex: \"\\u5165\\u529B\\u5024\",\n email: \"\\u30E1\\u30FC\\u30EB\\u30A2\\u30C9\\u30EC\\u30B9\",\n url: \"URL\",\n emoji: \"\\u7D75\\u6587\\u5B57\",\n uuid: \"UUID\",\n uuidv4: \"UUIDv4\",\n uuidv6: \"UUIDv6\",\n nanoid: \"nanoid\",\n guid: \"GUID\",\n cuid: \"cuid\",\n cuid2: \"cuid2\",\n ulid: \"ULID\",\n xid: \"XID\",\n ksuid: \"KSUID\",\n datetime: \"ISO\\u65E5\\u6642\",\n date: \"ISO\\u65E5\\u4ED8\",\n time: \"ISO\\u6642\\u523B\",\n duration: \"ISO\\u671F\\u9593\",\n ipv4: \"IPv4\\u30A2\\u30C9\\u30EC\\u30B9\",\n ipv6: \"IPv6\\u30A2\\u30C9\\u30EC\\u30B9\",\n cidrv4: \"IPv4\\u7BC4\\u56F2\",\n cidrv6: \"IPv6\\u7BC4\\u56F2\",\n base64: \"base64\\u30A8\\u30F3\\u30B3\\u30FC\\u30C9\\u6587\\u5B57\\u5217\",\n base64url: \"base64url\\u30A8\\u30F3\\u30B3\\u30FC\\u30C9\\u6587\\u5B57\\u5217\",\n json_string: \"JSON\\u6587\\u5B57\\u5217\",\n e164: \"E.164\\u756A\\u53F7\",\n jwt: \"JWT\",\n template_literal: \"\\u5165\\u529B\\u5024\"\n };\n const TypeDictionary = {\n nan: \"NaN\",\n number: \"\\u6570\\u5024\",\n array: \"\\u914D\\u5217\"\n };\n return (issue2) => {\n switch (issue2.code) {\n case \"invalid_type\": {\n const expected = TypeDictionary[issue2.expected] ?? issue2.expected;\n const receivedType = parsedType(issue2.input);\n const received = TypeDictionary[receivedType] ?? receivedType;\n if (/^[A-Z]/.test(issue2.expected)) {\n return `\\u7121\\u52B9\\u306A\\u5165\\u529B: instanceof ${issue2.expected}\\u304C\\u671F\\u5F85\\u3055\\u308C\\u307E\\u3057\\u305F\\u304C\\u3001${received}\\u304C\\u5165\\u529B\\u3055\\u308C\\u307E\\u3057\\u305F`;\n }\n return `\\u7121\\u52B9\\u306A\\u5165\\u529B: ${expected}\\u304C\\u671F\\u5F85\\u3055\\u308C\\u307E\\u3057\\u305F\\u304C\\u3001${received}\\u304C\\u5165\\u529B\\u3055\\u308C\\u307E\\u3057\\u305F`;\n }\n case \"invalid_value\":\n if (issue2.values.length === 1)\n return `\\u7121\\u52B9\\u306A\\u5165\\u529B: ${stringifyPrimitive(issue2.values[0])}\\u304C\\u671F\\u5F85\\u3055\\u308C\\u307E\\u3057\\u305F`;\n return `\\u7121\\u52B9\\u306A\\u9078\\u629E: ${joinValues(issue2.values, \"\\u3001\")}\\u306E\\u3044\\u305A\\u308C\\u304B\\u3067\\u3042\\u308B\\u5FC5\\u8981\\u304C\\u3042\\u308A\\u307E\\u3059`;\n case \"too_big\": {\n const adj = issue2.inclusive ? \"\\u4EE5\\u4E0B\\u3067\\u3042\\u308B\" : \"\\u3088\\u308A\\u5C0F\\u3055\\u3044\";\n const sizing = getSizing(issue2.origin);\n if (sizing)\n return `\\u5927\\u304D\\u3059\\u304E\\u308B\\u5024: ${issue2.origin ?? \"\\u5024\"}\\u306F${issue2.maximum.toString()}${sizing.unit ?? \"\\u8981\\u7D20\"}${adj}\\u5FC5\\u8981\\u304C\\u3042\\u308A\\u307E\\u3059`;\n return `\\u5927\\u304D\\u3059\\u304E\\u308B\\u5024: ${issue2.origin ?? \"\\u5024\"}\\u306F${issue2.maximum.toString()}${adj}\\u5FC5\\u8981\\u304C\\u3042\\u308A\\u307E\\u3059`;\n }\n case \"too_small\": {\n const adj = issue2.inclusive ? \"\\u4EE5\\u4E0A\\u3067\\u3042\\u308B\" : \"\\u3088\\u308A\\u5927\\u304D\\u3044\";\n const sizing = getSizing(issue2.origin);\n if (sizing)\n return `\\u5C0F\\u3055\\u3059\\u304E\\u308B\\u5024: ${issue2.origin}\\u306F${issue2.minimum.toString()}${sizing.unit}${adj}\\u5FC5\\u8981\\u304C\\u3042\\u308A\\u307E\\u3059`;\n return `\\u5C0F\\u3055\\u3059\\u304E\\u308B\\u5024: ${issue2.origin}\\u306F${issue2.minimum.toString()}${adj}\\u5FC5\\u8981\\u304C\\u3042\\u308A\\u307E\\u3059`;\n }\n case \"invalid_format\": {\n const _issue = issue2;\n if (_issue.format === \"starts_with\")\n return `\\u7121\\u52B9\\u306A\\u6587\\u5B57\\u5217: \"${_issue.prefix}\"\\u3067\\u59CB\\u307E\\u308B\\u5FC5\\u8981\\u304C\\u3042\\u308A\\u307E\\u3059`;\n if (_issue.format === \"ends_with\")\n return `\\u7121\\u52B9\\u306A\\u6587\\u5B57\\u5217: \"${_issue.suffix}\"\\u3067\\u7D42\\u308F\\u308B\\u5FC5\\u8981\\u304C\\u3042\\u308A\\u307E\\u3059`;\n if (_issue.format === \"includes\")\n return `\\u7121\\u52B9\\u306A\\u6587\\u5B57\\u5217: \"${_issue.includes}\"\\u3092\\u542B\\u3080\\u5FC5\\u8981\\u304C\\u3042\\u308A\\u307E\\u3059`;\n if (_issue.format === \"regex\")\n return `\\u7121\\u52B9\\u306A\\u6587\\u5B57\\u5217: \\u30D1\\u30BF\\u30FC\\u30F3${_issue.pattern}\\u306B\\u4E00\\u81F4\\u3059\\u308B\\u5FC5\\u8981\\u304C\\u3042\\u308A\\u307E\\u3059`;\n return `\\u7121\\u52B9\\u306A${FormatDictionary[_issue.format] ?? issue2.format}`;\n }\n case \"not_multiple_of\":\n return `\\u7121\\u52B9\\u306A\\u6570\\u5024: ${issue2.divisor}\\u306E\\u500D\\u6570\\u3067\\u3042\\u308B\\u5FC5\\u8981\\u304C\\u3042\\u308A\\u307E\\u3059`;\n case \"unrecognized_keys\":\n return `\\u8A8D\\u8B58\\u3055\\u308C\\u3066\\u3044\\u306A\\u3044\\u30AD\\u30FC${issue2.keys.length > 1 ? \"\\u7FA4\" : \"\"}: ${joinValues(issue2.keys, \"\\u3001\")}`;\n case \"invalid_key\":\n return `${issue2.origin}\\u5185\\u306E\\u7121\\u52B9\\u306A\\u30AD\\u30FC`;\n case \"invalid_union\":\n return \"\\u7121\\u52B9\\u306A\\u5165\\u529B\";\n case \"invalid_element\":\n return `${issue2.origin}\\u5185\\u306E\\u7121\\u52B9\\u306A\\u5024`;\n default:\n return `\\u7121\\u52B9\\u306A\\u5165\\u529B`;\n }\n };\n };\n function ja_default() {\n return {\n localeError: error22()\n };\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/ka.js\n var error23 = () => {\n const Sizable = {\n string: { unit: \"\\u10E1\\u10D8\\u10DB\\u10D1\\u10DD\\u10DA\\u10DD\", verb: \"\\u10E3\\u10DC\\u10D3\\u10D0 \\u10E8\\u10D4\\u10D8\\u10EA\\u10D0\\u10D5\\u10D3\\u10D4\\u10E1\" },\n file: { unit: \"\\u10D1\\u10D0\\u10D8\\u10E2\\u10D8\", verb: \"\\u10E3\\u10DC\\u10D3\\u10D0 \\u10E8\\u10D4\\u10D8\\u10EA\\u10D0\\u10D5\\u10D3\\u10D4\\u10E1\" },\n array: { unit: \"\\u10D4\\u10DA\\u10D4\\u10DB\\u10D4\\u10DC\\u10E2\\u10D8\", verb: \"\\u10E3\\u10DC\\u10D3\\u10D0 \\u10E8\\u10D4\\u10D8\\u10EA\\u10D0\\u10D5\\u10D3\\u10D4\\u10E1\" },\n set: { unit: \"\\u10D4\\u10DA\\u10D4\\u10DB\\u10D4\\u10DC\\u10E2\\u10D8\", verb: \"\\u10E3\\u10DC\\u10D3\\u10D0 \\u10E8\\u10D4\\u10D8\\u10EA\\u10D0\\u10D5\\u10D3\\u10D4\\u10E1\" }\n };\n function getSizing(origin) {\n return Sizable[origin] ?? null;\n }\n const FormatDictionary = {\n regex: \"\\u10E8\\u10D4\\u10E7\\u10D5\\u10D0\\u10DC\\u10D0\",\n email: \"\\u10D4\\u10DA-\\u10E4\\u10DD\\u10E1\\u10E2\\u10D8\\u10E1 \\u10DB\\u10D8\\u10E1\\u10D0\\u10DB\\u10D0\\u10E0\\u10D7\\u10D8\",\n url: \"URL\",\n emoji: \"\\u10D4\\u10DB\\u10DD\\u10EF\\u10D8\",\n uuid: \"UUID\",\n uuidv4: \"UUIDv4\",\n uuidv6: \"UUIDv6\",\n nanoid: \"nanoid\",\n guid: \"GUID\",\n cuid: \"cuid\",\n cuid2: \"cuid2\",\n ulid: \"ULID\",\n xid: \"XID\",\n ksuid: \"KSUID\",\n datetime: \"\\u10D7\\u10D0\\u10E0\\u10D8\\u10E6\\u10D8-\\u10D3\\u10E0\\u10DD\",\n date: \"\\u10D7\\u10D0\\u10E0\\u10D8\\u10E6\\u10D8\",\n time: \"\\u10D3\\u10E0\\u10DD\",\n duration: \"\\u10EE\\u10D0\\u10DC\\u10D2\\u10E0\\u10EB\\u10DA\\u10D8\\u10D5\\u10DD\\u10D1\\u10D0\",\n ipv4: \"IPv4 \\u10DB\\u10D8\\u10E1\\u10D0\\u10DB\\u10D0\\u10E0\\u10D7\\u10D8\",\n ipv6: \"IPv6 \\u10DB\\u10D8\\u10E1\\u10D0\\u10DB\\u10D0\\u10E0\\u10D7\\u10D8\",\n cidrv4: \"IPv4 \\u10D3\\u10D8\\u10D0\\u10DE\\u10D0\\u10D6\\u10DD\\u10DC\\u10D8\",\n cidrv6: \"IPv6 \\u10D3\\u10D8\\u10D0\\u10DE\\u10D0\\u10D6\\u10DD\\u10DC\\u10D8\",\n base64: \"base64-\\u10D9\\u10DD\\u10D3\\u10D8\\u10E0\\u10D4\\u10D1\\u10E3\\u10DA\\u10D8 \\u10E1\\u10E2\\u10E0\\u10D8\\u10DC\\u10D2\\u10D8\",\n base64url: \"base64url-\\u10D9\\u10DD\\u10D3\\u10D8\\u10E0\\u10D4\\u10D1\\u10E3\\u10DA\\u10D8 \\u10E1\\u10E2\\u10E0\\u10D8\\u10DC\\u10D2\\u10D8\",\n json_string: \"JSON \\u10E1\\u10E2\\u10E0\\u10D8\\u10DC\\u10D2\\u10D8\",\n e164: \"E.164 \\u10DC\\u10DD\\u10DB\\u10D4\\u10E0\\u10D8\",\n jwt: \"JWT\",\n template_literal: \"\\u10E8\\u10D4\\u10E7\\u10D5\\u10D0\\u10DC\\u10D0\"\n };\n const TypeDictionary = {\n nan: \"NaN\",\n number: \"\\u10E0\\u10D8\\u10EA\\u10EE\\u10D5\\u10D8\",\n string: \"\\u10E1\\u10E2\\u10E0\\u10D8\\u10DC\\u10D2\\u10D8\",\n boolean: \"\\u10D1\\u10E3\\u10DA\\u10D4\\u10D0\\u10DC\\u10D8\",\n function: \"\\u10E4\\u10E3\\u10DC\\u10E5\\u10EA\\u10D8\\u10D0\",\n array: \"\\u10DB\\u10D0\\u10E1\\u10D8\\u10D5\\u10D8\"\n };\n return (issue2) => {\n switch (issue2.code) {\n case \"invalid_type\": {\n const expected = TypeDictionary[issue2.expected] ?? issue2.expected;\n const receivedType = parsedType(issue2.input);\n const received = TypeDictionary[receivedType] ?? receivedType;\n if (/^[A-Z]/.test(issue2.expected)) {\n return `\\u10D0\\u10E0\\u10D0\\u10E1\\u10EC\\u10DD\\u10E0\\u10D8 \\u10E8\\u10D4\\u10E7\\u10D5\\u10D0\\u10DC\\u10D0: \\u10DB\\u10DD\\u10E1\\u10D0\\u10DA\\u10DD\\u10D3\\u10DC\\u10D4\\u10DA\\u10D8 instanceof ${issue2.expected}, \\u10DB\\u10D8\\u10E6\\u10D4\\u10D1\\u10E3\\u10DA\\u10D8 ${received}`;\n }\n return `\\u10D0\\u10E0\\u10D0\\u10E1\\u10EC\\u10DD\\u10E0\\u10D8 \\u10E8\\u10D4\\u10E7\\u10D5\\u10D0\\u10DC\\u10D0: \\u10DB\\u10DD\\u10E1\\u10D0\\u10DA\\u10DD\\u10D3\\u10DC\\u10D4\\u10DA\\u10D8 ${expected}, \\u10DB\\u10D8\\u10E6\\u10D4\\u10D1\\u10E3\\u10DA\\u10D8 ${received}`;\n }\n case \"invalid_value\":\n if (issue2.values.length === 1)\n return `\\u10D0\\u10E0\\u10D0\\u10E1\\u10EC\\u10DD\\u10E0\\u10D8 \\u10E8\\u10D4\\u10E7\\u10D5\\u10D0\\u10DC\\u10D0: \\u10DB\\u10DD\\u10E1\\u10D0\\u10DA\\u10DD\\u10D3\\u10DC\\u10D4\\u10DA\\u10D8 ${stringifyPrimitive(issue2.values[0])}`;\n return `\\u10D0\\u10E0\\u10D0\\u10E1\\u10EC\\u10DD\\u10E0\\u10D8 \\u10D5\\u10D0\\u10E0\\u10D8\\u10D0\\u10DC\\u10E2\\u10D8: \\u10DB\\u10DD\\u10E1\\u10D0\\u10DA\\u10DD\\u10D3\\u10DC\\u10D4\\u10DA\\u10D8\\u10D0 \\u10D4\\u10E0\\u10D7-\\u10D4\\u10E0\\u10D7\\u10D8 ${joinValues(issue2.values, \"|\")}-\\u10D3\\u10D0\\u10DC`;\n case \"too_big\": {\n const adj = issue2.inclusive ? \"<=\" : \"<\";\n const sizing = getSizing(issue2.origin);\n if (sizing)\n return `\\u10D6\\u10D4\\u10D3\\u10DB\\u10D4\\u10E2\\u10D0\\u10D3 \\u10D3\\u10D8\\u10D3\\u10D8: \\u10DB\\u10DD\\u10E1\\u10D0\\u10DA\\u10DD\\u10D3\\u10DC\\u10D4\\u10DA\\u10D8 ${issue2.origin ?? \"\\u10DB\\u10DC\\u10D8\\u10E8\\u10D5\\u10DC\\u10D4\\u10DA\\u10DD\\u10D1\\u10D0\"} ${sizing.verb} ${adj}${issue2.maximum.toString()} ${sizing.unit}`;\n return `\\u10D6\\u10D4\\u10D3\\u10DB\\u10D4\\u10E2\\u10D0\\u10D3 \\u10D3\\u10D8\\u10D3\\u10D8: \\u10DB\\u10DD\\u10E1\\u10D0\\u10DA\\u10DD\\u10D3\\u10DC\\u10D4\\u10DA\\u10D8 ${issue2.origin ?? \"\\u10DB\\u10DC\\u10D8\\u10E8\\u10D5\\u10DC\\u10D4\\u10DA\\u10DD\\u10D1\\u10D0\"} \\u10D8\\u10E7\\u10DD\\u10E1 ${adj}${issue2.maximum.toString()}`;\n }\n case \"too_small\": {\n const adj = issue2.inclusive ? \">=\" : \">\";\n const sizing = getSizing(issue2.origin);\n if (sizing) {\n return `\\u10D6\\u10D4\\u10D3\\u10DB\\u10D4\\u10E2\\u10D0\\u10D3 \\u10DE\\u10D0\\u10E2\\u10D0\\u10E0\\u10D0: \\u10DB\\u10DD\\u10E1\\u10D0\\u10DA\\u10DD\\u10D3\\u10DC\\u10D4\\u10DA\\u10D8 ${issue2.origin} ${sizing.verb} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;\n }\n return `\\u10D6\\u10D4\\u10D3\\u10DB\\u10D4\\u10E2\\u10D0\\u10D3 \\u10DE\\u10D0\\u10E2\\u10D0\\u10E0\\u10D0: \\u10DB\\u10DD\\u10E1\\u10D0\\u10DA\\u10DD\\u10D3\\u10DC\\u10D4\\u10DA\\u10D8 ${issue2.origin} \\u10D8\\u10E7\\u10DD\\u10E1 ${adj}${issue2.minimum.toString()}`;\n }\n case \"invalid_format\": {\n const _issue = issue2;\n if (_issue.format === \"starts_with\") {\n return `\\u10D0\\u10E0\\u10D0\\u10E1\\u10EC\\u10DD\\u10E0\\u10D8 \\u10E1\\u10E2\\u10E0\\u10D8\\u10DC\\u10D2\\u10D8: \\u10E3\\u10DC\\u10D3\\u10D0 \\u10D8\\u10EC\\u10E7\\u10D4\\u10D1\\u10DD\\u10D3\\u10D4\\u10E1 \"${_issue.prefix}\"-\\u10D8\\u10D7`;\n }\n if (_issue.format === \"ends_with\")\n return `\\u10D0\\u10E0\\u10D0\\u10E1\\u10EC\\u10DD\\u10E0\\u10D8 \\u10E1\\u10E2\\u10E0\\u10D8\\u10DC\\u10D2\\u10D8: \\u10E3\\u10DC\\u10D3\\u10D0 \\u10DB\\u10D7\\u10D0\\u10D5\\u10E0\\u10D3\\u10D4\\u10D1\\u10DD\\u10D3\\u10D4\\u10E1 \"${_issue.suffix}\"-\\u10D8\\u10D7`;\n if (_issue.format === \"includes\")\n return `\\u10D0\\u10E0\\u10D0\\u10E1\\u10EC\\u10DD\\u10E0\\u10D8 \\u10E1\\u10E2\\u10E0\\u10D8\\u10DC\\u10D2\\u10D8: \\u10E3\\u10DC\\u10D3\\u10D0 \\u10E8\\u10D4\\u10D8\\u10EA\\u10D0\\u10D5\\u10D3\\u10D4\\u10E1 \"${_issue.includes}\"-\\u10E1`;\n if (_issue.format === \"regex\")\n return `\\u10D0\\u10E0\\u10D0\\u10E1\\u10EC\\u10DD\\u10E0\\u10D8 \\u10E1\\u10E2\\u10E0\\u10D8\\u10DC\\u10D2\\u10D8: \\u10E3\\u10DC\\u10D3\\u10D0 \\u10E8\\u10D4\\u10D4\\u10E1\\u10D0\\u10D1\\u10D0\\u10DB\\u10D4\\u10D1\\u10DD\\u10D3\\u10D4\\u10E1 \\u10E8\\u10D0\\u10D1\\u10DA\\u10DD\\u10DC\\u10E1 ${_issue.pattern}`;\n return `\\u10D0\\u10E0\\u10D0\\u10E1\\u10EC\\u10DD\\u10E0\\u10D8 ${FormatDictionary[_issue.format] ?? issue2.format}`;\n }\n case \"not_multiple_of\":\n return `\\u10D0\\u10E0\\u10D0\\u10E1\\u10EC\\u10DD\\u10E0\\u10D8 \\u10E0\\u10D8\\u10EA\\u10EE\\u10D5\\u10D8: \\u10E3\\u10DC\\u10D3\\u10D0 \\u10D8\\u10E7\\u10DD\\u10E1 ${issue2.divisor}-\\u10D8\\u10E1 \\u10EF\\u10D4\\u10E0\\u10D0\\u10D3\\u10D8`;\n case \"unrecognized_keys\":\n return `\\u10E3\\u10EA\\u10DC\\u10DD\\u10D1\\u10D8 \\u10D2\\u10D0\\u10E1\\u10D0\\u10E6\\u10D4\\u10D1${issue2.keys.length > 1 ? \"\\u10D4\\u10D1\\u10D8\" : \"\\u10D8\"}: ${joinValues(issue2.keys, \", \")}`;\n case \"invalid_key\":\n return `\\u10D0\\u10E0\\u10D0\\u10E1\\u10EC\\u10DD\\u10E0\\u10D8 \\u10D2\\u10D0\\u10E1\\u10D0\\u10E6\\u10D4\\u10D1\\u10D8 ${issue2.origin}-\\u10E8\\u10D8`;\n case \"invalid_union\":\n return \"\\u10D0\\u10E0\\u10D0\\u10E1\\u10EC\\u10DD\\u10E0\\u10D8 \\u10E8\\u10D4\\u10E7\\u10D5\\u10D0\\u10DC\\u10D0\";\n case \"invalid_element\":\n return `\\u10D0\\u10E0\\u10D0\\u10E1\\u10EC\\u10DD\\u10E0\\u10D8 \\u10DB\\u10DC\\u10D8\\u10E8\\u10D5\\u10DC\\u10D4\\u10DA\\u10DD\\u10D1\\u10D0 ${issue2.origin}-\\u10E8\\u10D8`;\n default:\n return `\\u10D0\\u10E0\\u10D0\\u10E1\\u10EC\\u10DD\\u10E0\\u10D8 \\u10E8\\u10D4\\u10E7\\u10D5\\u10D0\\u10DC\\u10D0`;\n }\n };\n };\n function ka_default() {\n return {\n localeError: error23()\n };\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/km.js\n var error24 = () => {\n const Sizable = {\n string: { unit: \"\\u178F\\u17BD\\u17A2\\u1780\\u17D2\\u179F\\u179A\", verb: \"\\u1782\\u17BD\\u179A\\u1798\\u17B6\\u1793\" },\n file: { unit: \"\\u1794\\u17C3\", verb: \"\\u1782\\u17BD\\u179A\\u1798\\u17B6\\u1793\" },\n array: { unit: \"\\u1792\\u17B6\\u178F\\u17BB\", verb: \"\\u1782\\u17BD\\u179A\\u1798\\u17B6\\u1793\" },\n set: { unit: \"\\u1792\\u17B6\\u178F\\u17BB\", verb: \"\\u1782\\u17BD\\u179A\\u1798\\u17B6\\u1793\" }\n };\n function getSizing(origin) {\n return Sizable[origin] ?? null;\n }\n const FormatDictionary = {\n regex: \"\\u1791\\u17B7\\u1793\\u17D2\\u1793\\u1793\\u17D0\\u1799\\u1794\\u1789\\u17D2\\u1785\\u17BC\\u179B\",\n email: \"\\u17A2\\u17B6\\u179F\\u1799\\u178A\\u17D2\\u178B\\u17B6\\u1793\\u17A2\\u17CA\\u17B8\\u1798\\u17C2\\u179B\",\n url: \"URL\",\n emoji: \"\\u179F\\u1789\\u17D2\\u1789\\u17B6\\u17A2\\u17B6\\u179A\\u1798\\u17D2\\u1798\\u178E\\u17CD\",\n uuid: \"UUID\",\n uuidv4: \"UUIDv4\",\n uuidv6: \"UUIDv6\",\n nanoid: \"nanoid\",\n guid: \"GUID\",\n cuid: \"cuid\",\n cuid2: \"cuid2\",\n ulid: \"ULID\",\n xid: \"XID\",\n ksuid: \"KSUID\",\n datetime: \"\\u1780\\u17B6\\u179B\\u1794\\u179A\\u17B7\\u1785\\u17D2\\u1786\\u17C1\\u1791 \\u1793\\u17B7\\u1784\\u1798\\u17C9\\u17C4\\u1784 ISO\",\n date: \"\\u1780\\u17B6\\u179B\\u1794\\u179A\\u17B7\\u1785\\u17D2\\u1786\\u17C1\\u1791 ISO\",\n time: \"\\u1798\\u17C9\\u17C4\\u1784 ISO\",\n duration: \"\\u179A\\u1799\\u17C8\\u1796\\u17C1\\u179B ISO\",\n ipv4: \"\\u17A2\\u17B6\\u179F\\u1799\\u178A\\u17D2\\u178B\\u17B6\\u1793 IPv4\",\n ipv6: \"\\u17A2\\u17B6\\u179F\\u1799\\u178A\\u17D2\\u178B\\u17B6\\u1793 IPv6\",\n cidrv4: \"\\u178A\\u17C2\\u1793\\u17A2\\u17B6\\u179F\\u1799\\u178A\\u17D2\\u178B\\u17B6\\u1793 IPv4\",\n cidrv6: \"\\u178A\\u17C2\\u1793\\u17A2\\u17B6\\u179F\\u1799\\u178A\\u17D2\\u178B\\u17B6\\u1793 IPv6\",\n base64: \"\\u1781\\u17D2\\u179F\\u17C2\\u17A2\\u1780\\u17D2\\u179F\\u179A\\u17A2\\u17CA\\u17B7\\u1780\\u17BC\\u178A base64\",\n base64url: \"\\u1781\\u17D2\\u179F\\u17C2\\u17A2\\u1780\\u17D2\\u179F\\u179A\\u17A2\\u17CA\\u17B7\\u1780\\u17BC\\u178A base64url\",\n json_string: \"\\u1781\\u17D2\\u179F\\u17C2\\u17A2\\u1780\\u17D2\\u179F\\u179A JSON\",\n e164: \"\\u179B\\u17C1\\u1781 E.164\",\n jwt: \"JWT\",\n template_literal: \"\\u1791\\u17B7\\u1793\\u17D2\\u1793\\u1793\\u17D0\\u1799\\u1794\\u1789\\u17D2\\u1785\\u17BC\\u179B\"\n };\n const TypeDictionary = {\n nan: \"NaN\",\n number: \"\\u179B\\u17C1\\u1781\",\n array: \"\\u17A2\\u17B6\\u179A\\u17C1 (Array)\",\n null: \"\\u1782\\u17D2\\u1798\\u17B6\\u1793\\u178F\\u1798\\u17D2\\u179B\\u17C3 (null)\"\n };\n return (issue2) => {\n switch (issue2.code) {\n case \"invalid_type\": {\n const expected = TypeDictionary[issue2.expected] ?? issue2.expected;\n const receivedType = parsedType(issue2.input);\n const received = TypeDictionary[receivedType] ?? receivedType;\n if (/^[A-Z]/.test(issue2.expected)) {\n return `\\u1791\\u17B7\\u1793\\u17D2\\u1793\\u1793\\u17D0\\u1799\\u1794\\u1789\\u17D2\\u1785\\u17BC\\u179B\\u1798\\u17B7\\u1793\\u178F\\u17D2\\u179A\\u17B9\\u1798\\u178F\\u17D2\\u179A\\u17BC\\u179C\\u17D6 \\u178F\\u17D2\\u179A\\u17BC\\u179C\\u1780\\u17B6\\u179A instanceof ${issue2.expected} \\u1794\\u17C9\\u17BB\\u1793\\u17D2\\u178F\\u17C2\\u1791\\u1791\\u17BD\\u179B\\u1794\\u17B6\\u1793 ${received}`;\n }\n return `\\u1791\\u17B7\\u1793\\u17D2\\u1793\\u1793\\u17D0\\u1799\\u1794\\u1789\\u17D2\\u1785\\u17BC\\u179B\\u1798\\u17B7\\u1793\\u178F\\u17D2\\u179A\\u17B9\\u1798\\u178F\\u17D2\\u179A\\u17BC\\u179C\\u17D6 \\u178F\\u17D2\\u179A\\u17BC\\u179C\\u1780\\u17B6\\u179A ${expected} \\u1794\\u17C9\\u17BB\\u1793\\u17D2\\u178F\\u17C2\\u1791\\u1791\\u17BD\\u179B\\u1794\\u17B6\\u1793 ${received}`;\n }\n case \"invalid_value\":\n if (issue2.values.length === 1)\n return `\\u1791\\u17B7\\u1793\\u17D2\\u1793\\u1793\\u17D0\\u1799\\u1794\\u1789\\u17D2\\u1785\\u17BC\\u179B\\u1798\\u17B7\\u1793\\u178F\\u17D2\\u179A\\u17B9\\u1798\\u178F\\u17D2\\u179A\\u17BC\\u179C\\u17D6 \\u178F\\u17D2\\u179A\\u17BC\\u179C\\u1780\\u17B6\\u179A ${stringifyPrimitive(issue2.values[0])}`;\n return `\\u1787\\u1798\\u17D2\\u179A\\u17BE\\u179F\\u1798\\u17B7\\u1793\\u178F\\u17D2\\u179A\\u17B9\\u1798\\u178F\\u17D2\\u179A\\u17BC\\u179C\\u17D6 \\u178F\\u17D2\\u179A\\u17BC\\u179C\\u1787\\u17B6\\u1798\\u17BD\\u1799\\u1780\\u17D2\\u1793\\u17BB\\u1784\\u1785\\u17C6\\u178E\\u17C4\\u1798 ${joinValues(issue2.values, \"|\")}`;\n case \"too_big\": {\n const adj = issue2.inclusive ? \"<=\" : \"<\";\n const sizing = getSizing(issue2.origin);\n if (sizing)\n return `\\u1792\\u17C6\\u1796\\u17C1\\u1780\\u17D6 \\u178F\\u17D2\\u179A\\u17BC\\u179C\\u1780\\u17B6\\u179A ${issue2.origin ?? \"\\u178F\\u1798\\u17D2\\u179B\\u17C3\"} ${adj} ${issue2.maximum.toString()} ${sizing.unit ?? \"\\u1792\\u17B6\\u178F\\u17BB\"}`;\n return `\\u1792\\u17C6\\u1796\\u17C1\\u1780\\u17D6 \\u178F\\u17D2\\u179A\\u17BC\\u179C\\u1780\\u17B6\\u179A ${issue2.origin ?? \"\\u178F\\u1798\\u17D2\\u179B\\u17C3\"} ${adj} ${issue2.maximum.toString()}`;\n }\n case \"too_small\": {\n const adj = issue2.inclusive ? \">=\" : \">\";\n const sizing = getSizing(issue2.origin);\n if (sizing) {\n return `\\u178F\\u17BC\\u1785\\u1796\\u17C1\\u1780\\u17D6 \\u178F\\u17D2\\u179A\\u17BC\\u179C\\u1780\\u17B6\\u179A ${issue2.origin} ${adj} ${issue2.minimum.toString()} ${sizing.unit}`;\n }\n return `\\u178F\\u17BC\\u1785\\u1796\\u17C1\\u1780\\u17D6 \\u178F\\u17D2\\u179A\\u17BC\\u179C\\u1780\\u17B6\\u179A ${issue2.origin} ${adj} ${issue2.minimum.toString()}`;\n }\n case \"invalid_format\": {\n const _issue = issue2;\n if (_issue.format === \"starts_with\") {\n return `\\u1781\\u17D2\\u179F\\u17C2\\u17A2\\u1780\\u17D2\\u179F\\u179A\\u1798\\u17B7\\u1793\\u178F\\u17D2\\u179A\\u17B9\\u1798\\u178F\\u17D2\\u179A\\u17BC\\u179C\\u17D6 \\u178F\\u17D2\\u179A\\u17BC\\u179C\\u1785\\u17B6\\u1794\\u17CB\\u1795\\u17D2\\u178F\\u17BE\\u1798\\u178A\\u17C4\\u1799 \"${_issue.prefix}\"`;\n }\n if (_issue.format === \"ends_with\")\n return `\\u1781\\u17D2\\u179F\\u17C2\\u17A2\\u1780\\u17D2\\u179F\\u179A\\u1798\\u17B7\\u1793\\u178F\\u17D2\\u179A\\u17B9\\u1798\\u178F\\u17D2\\u179A\\u17BC\\u179C\\u17D6 \\u178F\\u17D2\\u179A\\u17BC\\u179C\\u1794\\u1789\\u17D2\\u1785\\u1794\\u17CB\\u178A\\u17C4\\u1799 \"${_issue.suffix}\"`;\n if (_issue.format === \"includes\")\n return `\\u1781\\u17D2\\u179F\\u17C2\\u17A2\\u1780\\u17D2\\u179F\\u179A\\u1798\\u17B7\\u1793\\u178F\\u17D2\\u179A\\u17B9\\u1798\\u178F\\u17D2\\u179A\\u17BC\\u179C\\u17D6 \\u178F\\u17D2\\u179A\\u17BC\\u179C\\u1798\\u17B6\\u1793 \"${_issue.includes}\"`;\n if (_issue.format === \"regex\")\n return `\\u1781\\u17D2\\u179F\\u17C2\\u17A2\\u1780\\u17D2\\u179F\\u179A\\u1798\\u17B7\\u1793\\u178F\\u17D2\\u179A\\u17B9\\u1798\\u178F\\u17D2\\u179A\\u17BC\\u179C\\u17D6 \\u178F\\u17D2\\u179A\\u17BC\\u179C\\u178F\\u17C2\\u1795\\u17D2\\u1782\\u17BC\\u1795\\u17D2\\u1782\\u1784\\u1793\\u17B9\\u1784\\u1791\\u1798\\u17D2\\u179A\\u1784\\u17CB\\u178A\\u17C2\\u179B\\u1794\\u17B6\\u1793\\u1780\\u17C6\\u178E\\u178F\\u17CB ${_issue.pattern}`;\n return `\\u1798\\u17B7\\u1793\\u178F\\u17D2\\u179A\\u17B9\\u1798\\u178F\\u17D2\\u179A\\u17BC\\u179C\\u17D6 ${FormatDictionary[_issue.format] ?? issue2.format}`;\n }\n case \"not_multiple_of\":\n return `\\u179B\\u17C1\\u1781\\u1798\\u17B7\\u1793\\u178F\\u17D2\\u179A\\u17B9\\u1798\\u178F\\u17D2\\u179A\\u17BC\\u179C\\u17D6 \\u178F\\u17D2\\u179A\\u17BC\\u179C\\u178F\\u17C2\\u1787\\u17B6\\u1796\\u17A0\\u17BB\\u1782\\u17BB\\u178E\\u1793\\u17C3 ${issue2.divisor}`;\n case \"unrecognized_keys\":\n return `\\u179A\\u1780\\u1783\\u17BE\\u1789\\u179F\\u17C4\\u1798\\u17B7\\u1793\\u179F\\u17D2\\u1782\\u17B6\\u179B\\u17CB\\u17D6 ${joinValues(issue2.keys, \", \")}`;\n case \"invalid_key\":\n return `\\u179F\\u17C4\\u1798\\u17B7\\u1793\\u178F\\u17D2\\u179A\\u17B9\\u1798\\u178F\\u17D2\\u179A\\u17BC\\u179C\\u1793\\u17C5\\u1780\\u17D2\\u1793\\u17BB\\u1784 ${issue2.origin}`;\n case \"invalid_union\":\n return `\\u1791\\u17B7\\u1793\\u17D2\\u1793\\u1793\\u17D0\\u1799\\u1798\\u17B7\\u1793\\u178F\\u17D2\\u179A\\u17B9\\u1798\\u178F\\u17D2\\u179A\\u17BC\\u179C`;\n case \"invalid_element\":\n return `\\u1791\\u17B7\\u1793\\u17D2\\u1793\\u1793\\u17D0\\u1799\\u1798\\u17B7\\u1793\\u178F\\u17D2\\u179A\\u17B9\\u1798\\u178F\\u17D2\\u179A\\u17BC\\u179C\\u1793\\u17C5\\u1780\\u17D2\\u1793\\u17BB\\u1784 ${issue2.origin}`;\n default:\n return `\\u1791\\u17B7\\u1793\\u17D2\\u1793\\u1793\\u17D0\\u1799\\u1798\\u17B7\\u1793\\u178F\\u17D2\\u179A\\u17B9\\u1798\\u178F\\u17D2\\u179A\\u17BC\\u179C`;\n }\n };\n };\n function km_default() {\n return {\n localeError: error24()\n };\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/kh.js\n function kh_default() {\n return km_default();\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/ko.js\n var error25 = () => {\n const Sizable = {\n string: { unit: \"\\uBB38\\uC790\", verb: \"to have\" },\n file: { unit: \"\\uBC14\\uC774\\uD2B8\", verb: \"to have\" },\n array: { unit: \"\\uAC1C\", verb: \"to have\" },\n set: { unit: \"\\uAC1C\", verb: \"to have\" }\n };\n function getSizing(origin) {\n return Sizable[origin] ?? null;\n }\n const FormatDictionary = {\n regex: \"\\uC785\\uB825\",\n email: \"\\uC774\\uBA54\\uC77C \\uC8FC\\uC18C\",\n url: \"URL\",\n emoji: \"\\uC774\\uBAA8\\uC9C0\",\n uuid: \"UUID\",\n uuidv4: \"UUIDv4\",\n uuidv6: \"UUIDv6\",\n nanoid: \"nanoid\",\n guid: \"GUID\",\n cuid: \"cuid\",\n cuid2: \"cuid2\",\n ulid: \"ULID\",\n xid: \"XID\",\n ksuid: \"KSUID\",\n datetime: \"ISO \\uB0A0\\uC9DC\\uC2DC\\uAC04\",\n date: \"ISO \\uB0A0\\uC9DC\",\n time: \"ISO \\uC2DC\\uAC04\",\n duration: \"ISO \\uAE30\\uAC04\",\n ipv4: \"IPv4 \\uC8FC\\uC18C\",\n ipv6: \"IPv6 \\uC8FC\\uC18C\",\n cidrv4: \"IPv4 \\uBC94\\uC704\",\n cidrv6: \"IPv6 \\uBC94\\uC704\",\n base64: \"base64 \\uC778\\uCF54\\uB529 \\uBB38\\uC790\\uC5F4\",\n base64url: \"base64url \\uC778\\uCF54\\uB529 \\uBB38\\uC790\\uC5F4\",\n json_string: \"JSON \\uBB38\\uC790\\uC5F4\",\n e164: \"E.164 \\uBC88\\uD638\",\n jwt: \"JWT\",\n template_literal: \"\\uC785\\uB825\"\n };\n const TypeDictionary = {\n nan: \"NaN\"\n };\n return (issue2) => {\n switch (issue2.code) {\n case \"invalid_type\": {\n const expected = TypeDictionary[issue2.expected] ?? issue2.expected;\n const receivedType = parsedType(issue2.input);\n const received = TypeDictionary[receivedType] ?? receivedType;\n if (/^[A-Z]/.test(issue2.expected)) {\n return `\\uC798\\uBABB\\uB41C \\uC785\\uB825: \\uC608\\uC0C1 \\uD0C0\\uC785\\uC740 instanceof ${issue2.expected}, \\uBC1B\\uC740 \\uD0C0\\uC785\\uC740 ${received}\\uC785\\uB2C8\\uB2E4`;\n }\n return `\\uC798\\uBABB\\uB41C \\uC785\\uB825: \\uC608\\uC0C1 \\uD0C0\\uC785\\uC740 ${expected}, \\uBC1B\\uC740 \\uD0C0\\uC785\\uC740 ${received}\\uC785\\uB2C8\\uB2E4`;\n }\n case \"invalid_value\":\n if (issue2.values.length === 1)\n return `\\uC798\\uBABB\\uB41C \\uC785\\uB825: \\uAC12\\uC740 ${stringifyPrimitive(issue2.values[0])} \\uC774\\uC5B4\\uC57C \\uD569\\uB2C8\\uB2E4`;\n return `\\uC798\\uBABB\\uB41C \\uC635\\uC158: ${joinValues(issue2.values, \"\\uB610\\uB294 \")} \\uC911 \\uD558\\uB098\\uC5EC\\uC57C \\uD569\\uB2C8\\uB2E4`;\n case \"too_big\": {\n const adj = issue2.inclusive ? \"\\uC774\\uD558\" : \"\\uBBF8\\uB9CC\";\n const suffix = adj === \"\\uBBF8\\uB9CC\" ? \"\\uC774\\uC5B4\\uC57C \\uD569\\uB2C8\\uB2E4\" : \"\\uC5EC\\uC57C \\uD569\\uB2C8\\uB2E4\";\n const sizing = getSizing(issue2.origin);\n const unit = sizing?.unit ?? \"\\uC694\\uC18C\";\n if (sizing)\n return `${issue2.origin ?? \"\\uAC12\"}\\uC774 \\uB108\\uBB34 \\uD07D\\uB2C8\\uB2E4: ${issue2.maximum.toString()}${unit} ${adj}${suffix}`;\n return `${issue2.origin ?? \"\\uAC12\"}\\uC774 \\uB108\\uBB34 \\uD07D\\uB2C8\\uB2E4: ${issue2.maximum.toString()} ${adj}${suffix}`;\n }\n case \"too_small\": {\n const adj = issue2.inclusive ? \"\\uC774\\uC0C1\" : \"\\uCD08\\uACFC\";\n const suffix = adj === \"\\uC774\\uC0C1\" ? \"\\uC774\\uC5B4\\uC57C \\uD569\\uB2C8\\uB2E4\" : \"\\uC5EC\\uC57C \\uD569\\uB2C8\\uB2E4\";\n const sizing = getSizing(issue2.origin);\n const unit = sizing?.unit ?? \"\\uC694\\uC18C\";\n if (sizing) {\n return `${issue2.origin ?? \"\\uAC12\"}\\uC774 \\uB108\\uBB34 \\uC791\\uC2B5\\uB2C8\\uB2E4: ${issue2.minimum.toString()}${unit} ${adj}${suffix}`;\n }\n return `${issue2.origin ?? \"\\uAC12\"}\\uC774 \\uB108\\uBB34 \\uC791\\uC2B5\\uB2C8\\uB2E4: ${issue2.minimum.toString()} ${adj}${suffix}`;\n }\n case \"invalid_format\": {\n const _issue = issue2;\n if (_issue.format === \"starts_with\") {\n return `\\uC798\\uBABB\\uB41C \\uBB38\\uC790\\uC5F4: \"${_issue.prefix}\"(\\uC73C)\\uB85C \\uC2DC\\uC791\\uD574\\uC57C \\uD569\\uB2C8\\uB2E4`;\n }\n if (_issue.format === \"ends_with\")\n return `\\uC798\\uBABB\\uB41C \\uBB38\\uC790\\uC5F4: \"${_issue.suffix}\"(\\uC73C)\\uB85C \\uB05D\\uB098\\uC57C \\uD569\\uB2C8\\uB2E4`;\n if (_issue.format === \"includes\")\n return `\\uC798\\uBABB\\uB41C \\uBB38\\uC790\\uC5F4: \"${_issue.includes}\"\\uC744(\\uB97C) \\uD3EC\\uD568\\uD574\\uC57C \\uD569\\uB2C8\\uB2E4`;\n if (_issue.format === \"regex\")\n return `\\uC798\\uBABB\\uB41C \\uBB38\\uC790\\uC5F4: \\uC815\\uADDC\\uC2DD ${_issue.pattern} \\uD328\\uD134\\uACFC \\uC77C\\uCE58\\uD574\\uC57C \\uD569\\uB2C8\\uB2E4`;\n return `\\uC798\\uBABB\\uB41C ${FormatDictionary[_issue.format] ?? issue2.format}`;\n }\n case \"not_multiple_of\":\n return `\\uC798\\uBABB\\uB41C \\uC22B\\uC790: ${issue2.divisor}\\uC758 \\uBC30\\uC218\\uC5EC\\uC57C \\uD569\\uB2C8\\uB2E4`;\n case \"unrecognized_keys\":\n return `\\uC778\\uC2DD\\uD560 \\uC218 \\uC5C6\\uB294 \\uD0A4: ${joinValues(issue2.keys, \", \")}`;\n case \"invalid_key\":\n return `\\uC798\\uBABB\\uB41C \\uD0A4: ${issue2.origin}`;\n case \"invalid_union\":\n return `\\uC798\\uBABB\\uB41C \\uC785\\uB825`;\n case \"invalid_element\":\n return `\\uC798\\uBABB\\uB41C \\uAC12: ${issue2.origin}`;\n default:\n return `\\uC798\\uBABB\\uB41C \\uC785\\uB825`;\n }\n };\n };\n function ko_default() {\n return {\n localeError: error25()\n };\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/lt.js\n var capitalizeFirstCharacter = (text) => {\n return text.charAt(0).toUpperCase() + text.slice(1);\n };\n function getUnitTypeFromNumber(number4) {\n const abs = Math.abs(number4);\n const last = abs % 10;\n const last2 = abs % 100;\n if (last2 >= 11 && last2 <= 19 || last === 0)\n return \"many\";\n if (last === 1)\n return \"one\";\n return \"few\";\n }\n var error26 = () => {\n const Sizable = {\n string: {\n unit: {\n one: \"simbolis\",\n few: \"simboliai\",\n many: \"simboli\\u0173\"\n },\n verb: {\n smaller: {\n inclusive: \"turi b\\u016Bti ne ilgesn\\u0117 kaip\",\n notInclusive: \"turi b\\u016Bti trumpesn\\u0117 kaip\"\n },\n bigger: {\n inclusive: \"turi b\\u016Bti ne trumpesn\\u0117 kaip\",\n notInclusive: \"turi b\\u016Bti ilgesn\\u0117 kaip\"\n }\n }\n },\n file: {\n unit: {\n one: \"baitas\",\n few: \"baitai\",\n many: \"bait\\u0173\"\n },\n verb: {\n smaller: {\n inclusive: \"turi b\\u016Bti ne didesnis kaip\",\n notInclusive: \"turi b\\u016Bti ma\\u017Eesnis kaip\"\n },\n bigger: {\n inclusive: \"turi b\\u016Bti ne ma\\u017Eesnis kaip\",\n notInclusive: \"turi b\\u016Bti didesnis kaip\"\n }\n }\n },\n array: {\n unit: {\n one: \"element\\u0105\",\n few: \"elementus\",\n many: \"element\\u0173\"\n },\n verb: {\n smaller: {\n inclusive: \"turi tur\\u0117ti ne daugiau kaip\",\n notInclusive: \"turi tur\\u0117ti ma\\u017Eiau kaip\"\n },\n bigger: {\n inclusive: \"turi tur\\u0117ti ne ma\\u017Eiau kaip\",\n notInclusive: \"turi tur\\u0117ti daugiau kaip\"\n }\n }\n },\n set: {\n unit: {\n one: \"element\\u0105\",\n few: \"elementus\",\n many: \"element\\u0173\"\n },\n verb: {\n smaller: {\n inclusive: \"turi tur\\u0117ti ne daugiau kaip\",\n notInclusive: \"turi tur\\u0117ti ma\\u017Eiau kaip\"\n },\n bigger: {\n inclusive: \"turi tur\\u0117ti ne ma\\u017Eiau kaip\",\n notInclusive: \"turi tur\\u0117ti daugiau kaip\"\n }\n }\n }\n };\n function getSizing(origin, unitType, inclusive, targetShouldBe) {\n const result = Sizable[origin] ?? null;\n if (result === null)\n return result;\n return {\n unit: result.unit[unitType],\n verb: result.verb[targetShouldBe][inclusive ? \"inclusive\" : \"notInclusive\"]\n };\n }\n const FormatDictionary = {\n regex: \"\\u012Fvestis\",\n email: \"el. pa\\u0161to adresas\",\n url: \"URL\",\n emoji: \"jaustukas\",\n uuid: \"UUID\",\n uuidv4: \"UUIDv4\",\n uuidv6: \"UUIDv6\",\n nanoid: \"nanoid\",\n guid: \"GUID\",\n cuid: \"cuid\",\n cuid2: \"cuid2\",\n ulid: \"ULID\",\n xid: \"XID\",\n ksuid: \"KSUID\",\n datetime: \"ISO data ir laikas\",\n date: \"ISO data\",\n time: \"ISO laikas\",\n duration: \"ISO trukm\\u0117\",\n ipv4: \"IPv4 adresas\",\n ipv6: \"IPv6 adresas\",\n cidrv4: \"IPv4 tinklo prefiksas (CIDR)\",\n cidrv6: \"IPv6 tinklo prefiksas (CIDR)\",\n base64: \"base64 u\\u017Ekoduota eilut\\u0117\",\n base64url: \"base64url u\\u017Ekoduota eilut\\u0117\",\n json_string: \"JSON eilut\\u0117\",\n e164: \"E.164 numeris\",\n jwt: \"JWT\",\n template_literal: \"\\u012Fvestis\"\n };\n const TypeDictionary = {\n nan: \"NaN\",\n number: \"skai\\u010Dius\",\n bigint: \"sveikasis skai\\u010Dius\",\n string: \"eilut\\u0117\",\n boolean: \"login\\u0117 reik\\u0161m\\u0117\",\n undefined: \"neapibr\\u0117\\u017Eta reik\\u0161m\\u0117\",\n function: \"funkcija\",\n symbol: \"simbolis\",\n array: \"masyvas\",\n object: \"objektas\",\n null: \"nulin\\u0117 reik\\u0161m\\u0117\"\n };\n return (issue2) => {\n switch (issue2.code) {\n case \"invalid_type\": {\n const expected = TypeDictionary[issue2.expected] ?? issue2.expected;\n const receivedType = parsedType(issue2.input);\n const received = TypeDictionary[receivedType] ?? receivedType;\n if (/^[A-Z]/.test(issue2.expected)) {\n return `Gautas tipas ${received}, o tik\\u0117tasi - instanceof ${issue2.expected}`;\n }\n return `Gautas tipas ${received}, o tik\\u0117tasi - ${expected}`;\n }\n case \"invalid_value\":\n if (issue2.values.length === 1)\n return `Privalo b\\u016Bti ${stringifyPrimitive(issue2.values[0])}`;\n return `Privalo b\\u016Bti vienas i\\u0161 ${joinValues(issue2.values, \"|\")} pasirinkim\\u0173`;\n case \"too_big\": {\n const origin = TypeDictionary[issue2.origin] ?? issue2.origin;\n const sizing = getSizing(issue2.origin, getUnitTypeFromNumber(Number(issue2.maximum)), issue2.inclusive ?? false, \"smaller\");\n if (sizing?.verb)\n return `${capitalizeFirstCharacter(origin ?? issue2.origin ?? \"reik\\u0161m\\u0117\")} ${sizing.verb} ${issue2.maximum.toString()} ${sizing.unit ?? \"element\\u0173\"}`;\n const adj = issue2.inclusive ? \"ne didesnis kaip\" : \"ma\\u017Eesnis kaip\";\n return `${capitalizeFirstCharacter(origin ?? issue2.origin ?? \"reik\\u0161m\\u0117\")} turi b\\u016Bti ${adj} ${issue2.maximum.toString()} ${sizing?.unit}`;\n }\n case \"too_small\": {\n const origin = TypeDictionary[issue2.origin] ?? issue2.origin;\n const sizing = getSizing(issue2.origin, getUnitTypeFromNumber(Number(issue2.minimum)), issue2.inclusive ?? false, \"bigger\");\n if (sizing?.verb)\n return `${capitalizeFirstCharacter(origin ?? issue2.origin ?? \"reik\\u0161m\\u0117\")} ${sizing.verb} ${issue2.minimum.toString()} ${sizing.unit ?? \"element\\u0173\"}`;\n const adj = issue2.inclusive ? \"ne ma\\u017Eesnis kaip\" : \"didesnis kaip\";\n return `${capitalizeFirstCharacter(origin ?? issue2.origin ?? \"reik\\u0161m\\u0117\")} turi b\\u016Bti ${adj} ${issue2.minimum.toString()} ${sizing?.unit}`;\n }\n case \"invalid_format\": {\n const _issue = issue2;\n if (_issue.format === \"starts_with\") {\n return `Eilut\\u0117 privalo prasid\\u0117ti \"${_issue.prefix}\"`;\n }\n if (_issue.format === \"ends_with\")\n return `Eilut\\u0117 privalo pasibaigti \"${_issue.suffix}\"`;\n if (_issue.format === \"includes\")\n return `Eilut\\u0117 privalo \\u012Ftraukti \"${_issue.includes}\"`;\n if (_issue.format === \"regex\")\n return `Eilut\\u0117 privalo atitikti ${_issue.pattern}`;\n return `Neteisingas ${FormatDictionary[_issue.format] ?? issue2.format}`;\n }\n case \"not_multiple_of\":\n return `Skai\\u010Dius privalo b\\u016Bti ${issue2.divisor} kartotinis.`;\n case \"unrecognized_keys\":\n return `Neatpa\\u017Eint${issue2.keys.length > 1 ? \"i\" : \"as\"} rakt${issue2.keys.length > 1 ? \"ai\" : \"as\"}: ${joinValues(issue2.keys, \", \")}`;\n case \"invalid_key\":\n return \"Rastas klaidingas raktas\";\n case \"invalid_union\":\n return \"Klaidinga \\u012Fvestis\";\n case \"invalid_element\": {\n const origin = TypeDictionary[issue2.origin] ?? issue2.origin;\n return `${capitalizeFirstCharacter(origin ?? issue2.origin ?? \"reik\\u0161m\\u0117\")} turi klaiding\\u0105 \\u012Fvest\\u012F`;\n }\n default:\n return \"Klaidinga \\u012Fvestis\";\n }\n };\n };\n function lt_default() {\n return {\n localeError: error26()\n };\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/mk.js\n var error27 = () => {\n const Sizable = {\n string: { unit: \"\\u0437\\u043D\\u0430\\u0446\\u0438\", verb: \"\\u0434\\u0430 \\u0438\\u043C\\u0430\\u0430\\u0442\" },\n file: { unit: \"\\u0431\\u0430\\u0458\\u0442\\u0438\", verb: \"\\u0434\\u0430 \\u0438\\u043C\\u0430\\u0430\\u0442\" },\n array: { unit: \"\\u0441\\u0442\\u0430\\u0432\\u043A\\u0438\", verb: \"\\u0434\\u0430 \\u0438\\u043C\\u0430\\u0430\\u0442\" },\n set: { unit: \"\\u0441\\u0442\\u0430\\u0432\\u043A\\u0438\", verb: \"\\u0434\\u0430 \\u0438\\u043C\\u0430\\u0430\\u0442\" }\n };\n function getSizing(origin) {\n return Sizable[origin] ?? null;\n }\n const FormatDictionary = {\n regex: \"\\u0432\\u043D\\u0435\\u0441\",\n email: \"\\u0430\\u0434\\u0440\\u0435\\u0441\\u0430 \\u043D\\u0430 \\u0435-\\u043F\\u043E\\u0448\\u0442\\u0430\",\n url: \"URL\",\n emoji: \"\\u0435\\u043C\\u043E\\u045F\\u0438\",\n uuid: \"UUID\",\n uuidv4: \"UUIDv4\",\n uuidv6: \"UUIDv6\",\n nanoid: \"nanoid\",\n guid: \"GUID\",\n cuid: \"cuid\",\n cuid2: \"cuid2\",\n ulid: \"ULID\",\n xid: \"XID\",\n ksuid: \"KSUID\",\n datetime: \"ISO \\u0434\\u0430\\u0442\\u0443\\u043C \\u0438 \\u0432\\u0440\\u0435\\u043C\\u0435\",\n date: \"ISO \\u0434\\u0430\\u0442\\u0443\\u043C\",\n time: \"ISO \\u0432\\u0440\\u0435\\u043C\\u0435\",\n duration: \"ISO \\u0432\\u0440\\u0435\\u043C\\u0435\\u0442\\u0440\\u0430\\u0435\\u045A\\u0435\",\n ipv4: \"IPv4 \\u0430\\u0434\\u0440\\u0435\\u0441\\u0430\",\n ipv6: \"IPv6 \\u0430\\u0434\\u0440\\u0435\\u0441\\u0430\",\n cidrv4: \"IPv4 \\u043E\\u043F\\u0441\\u0435\\u0433\",\n cidrv6: \"IPv6 \\u043E\\u043F\\u0441\\u0435\\u0433\",\n base64: \"base64-\\u0435\\u043D\\u043A\\u043E\\u0434\\u0438\\u0440\\u0430\\u043D\\u0430 \\u043D\\u0438\\u0437\\u0430\",\n base64url: \"base64url-\\u0435\\u043D\\u043A\\u043E\\u0434\\u0438\\u0440\\u0430\\u043D\\u0430 \\u043D\\u0438\\u0437\\u0430\",\n json_string: \"JSON \\u043D\\u0438\\u0437\\u0430\",\n e164: \"E.164 \\u0431\\u0440\\u043E\\u0458\",\n jwt: \"JWT\",\n template_literal: \"\\u0432\\u043D\\u0435\\u0441\"\n };\n const TypeDictionary = {\n nan: \"NaN\",\n number: \"\\u0431\\u0440\\u043E\\u0458\",\n array: \"\\u043D\\u0438\\u0437\\u0430\"\n };\n return (issue2) => {\n switch (issue2.code) {\n case \"invalid_type\": {\n const expected = TypeDictionary[issue2.expected] ?? issue2.expected;\n const receivedType = parsedType(issue2.input);\n const received = TypeDictionary[receivedType] ?? receivedType;\n if (/^[A-Z]/.test(issue2.expected)) {\n return `\\u0413\\u0440\\u0435\\u0448\\u0435\\u043D \\u0432\\u043D\\u0435\\u0441: \\u0441\\u0435 \\u043E\\u0447\\u0435\\u043A\\u0443\\u0432\\u0430 instanceof ${issue2.expected}, \\u043F\\u0440\\u0438\\u043C\\u0435\\u043D\\u043E ${received}`;\n }\n return `\\u0413\\u0440\\u0435\\u0448\\u0435\\u043D \\u0432\\u043D\\u0435\\u0441: \\u0441\\u0435 \\u043E\\u0447\\u0435\\u043A\\u0443\\u0432\\u0430 ${expected}, \\u043F\\u0440\\u0438\\u043C\\u0435\\u043D\\u043E ${received}`;\n }\n case \"invalid_value\":\n if (issue2.values.length === 1)\n return `Invalid input: expected ${stringifyPrimitive(issue2.values[0])}`;\n return `\\u0413\\u0440\\u0435\\u0448\\u0430\\u043D\\u0430 \\u043E\\u043F\\u0446\\u0438\\u0458\\u0430: \\u0441\\u0435 \\u043E\\u0447\\u0435\\u043A\\u0443\\u0432\\u0430 \\u0435\\u0434\\u043D\\u0430 ${joinValues(issue2.values, \"|\")}`;\n case \"too_big\": {\n const adj = issue2.inclusive ? \"<=\" : \"<\";\n const sizing = getSizing(issue2.origin);\n if (sizing)\n return `\\u041F\\u0440\\u0435\\u043C\\u043D\\u043E\\u0433\\u0443 \\u0433\\u043E\\u043B\\u0435\\u043C: \\u0441\\u0435 \\u043E\\u0447\\u0435\\u043A\\u0443\\u0432\\u0430 ${issue2.origin ?? \"\\u0432\\u0440\\u0435\\u0434\\u043D\\u043E\\u0441\\u0442\\u0430\"} \\u0434\\u0430 \\u0438\\u043C\\u0430 ${adj}${issue2.maximum.toString()} ${sizing.unit ?? \"\\u0435\\u043B\\u0435\\u043C\\u0435\\u043D\\u0442\\u0438\"}`;\n return `\\u041F\\u0440\\u0435\\u043C\\u043D\\u043E\\u0433\\u0443 \\u0433\\u043E\\u043B\\u0435\\u043C: \\u0441\\u0435 \\u043E\\u0447\\u0435\\u043A\\u0443\\u0432\\u0430 ${issue2.origin ?? \"\\u0432\\u0440\\u0435\\u0434\\u043D\\u043E\\u0441\\u0442\\u0430\"} \\u0434\\u0430 \\u0431\\u0438\\u0434\\u0435 ${adj}${issue2.maximum.toString()}`;\n }\n case \"too_small\": {\n const adj = issue2.inclusive ? \">=\" : \">\";\n const sizing = getSizing(issue2.origin);\n if (sizing) {\n return `\\u041F\\u0440\\u0435\\u043C\\u043D\\u043E\\u0433\\u0443 \\u043C\\u0430\\u043B: \\u0441\\u0435 \\u043E\\u0447\\u0435\\u043A\\u0443\\u0432\\u0430 ${issue2.origin} \\u0434\\u0430 \\u0438\\u043C\\u0430 ${adj}${issue2.minimum.toString()} ${sizing.unit}`;\n }\n return `\\u041F\\u0440\\u0435\\u043C\\u043D\\u043E\\u0433\\u0443 \\u043C\\u0430\\u043B: \\u0441\\u0435 \\u043E\\u0447\\u0435\\u043A\\u0443\\u0432\\u0430 ${issue2.origin} \\u0434\\u0430 \\u0431\\u0438\\u0434\\u0435 ${adj}${issue2.minimum.toString()}`;\n }\n case \"invalid_format\": {\n const _issue = issue2;\n if (_issue.format === \"starts_with\") {\n return `\\u041D\\u0435\\u0432\\u0430\\u0436\\u0435\\u0447\\u043A\\u0430 \\u043D\\u0438\\u0437\\u0430: \\u043C\\u043E\\u0440\\u0430 \\u0434\\u0430 \\u0437\\u0430\\u043F\\u043E\\u0447\\u043D\\u0443\\u0432\\u0430 \\u0441\\u043E \"${_issue.prefix}\"`;\n }\n if (_issue.format === \"ends_with\")\n return `\\u041D\\u0435\\u0432\\u0430\\u0436\\u0435\\u0447\\u043A\\u0430 \\u043D\\u0438\\u0437\\u0430: \\u043C\\u043E\\u0440\\u0430 \\u0434\\u0430 \\u0437\\u0430\\u0432\\u0440\\u0448\\u0443\\u0432\\u0430 \\u0441\\u043E \"${_issue.suffix}\"`;\n if (_issue.format === \"includes\")\n return `\\u041D\\u0435\\u0432\\u0430\\u0436\\u0435\\u0447\\u043A\\u0430 \\u043D\\u0438\\u0437\\u0430: \\u043C\\u043E\\u0440\\u0430 \\u0434\\u0430 \\u0432\\u043A\\u043B\\u0443\\u0447\\u0443\\u0432\\u0430 \"${_issue.includes}\"`;\n if (_issue.format === \"regex\")\n return `\\u041D\\u0435\\u0432\\u0430\\u0436\\u0435\\u0447\\u043A\\u0430 \\u043D\\u0438\\u0437\\u0430: \\u043C\\u043E\\u0440\\u0430 \\u0434\\u0430 \\u043E\\u0434\\u0433\\u043E\\u0430\\u0440\\u0430 \\u043D\\u0430 \\u043F\\u0430\\u0442\\u0435\\u0440\\u043D\\u043E\\u0442 ${_issue.pattern}`;\n return `Invalid ${FormatDictionary[_issue.format] ?? issue2.format}`;\n }\n case \"not_multiple_of\":\n return `\\u0413\\u0440\\u0435\\u0448\\u0435\\u043D \\u0431\\u0440\\u043E\\u0458: \\u043C\\u043E\\u0440\\u0430 \\u0434\\u0430 \\u0431\\u0438\\u0434\\u0435 \\u0434\\u0435\\u043B\\u0438\\u0432 \\u0441\\u043E ${issue2.divisor}`;\n case \"unrecognized_keys\":\n return `${issue2.keys.length > 1 ? \"\\u041D\\u0435\\u043F\\u0440\\u0435\\u043F\\u043E\\u0437\\u043D\\u0430\\u0435\\u043D\\u0438 \\u043A\\u043B\\u0443\\u0447\\u0435\\u0432\\u0438\" : \"\\u041D\\u0435\\u043F\\u0440\\u0435\\u043F\\u043E\\u0437\\u043D\\u0430\\u0435\\u043D \\u043A\\u043B\\u0443\\u0447\"}: ${joinValues(issue2.keys, \", \")}`;\n case \"invalid_key\":\n return `\\u0413\\u0440\\u0435\\u0448\\u0435\\u043D \\u043A\\u043B\\u0443\\u0447 \\u0432\\u043E ${issue2.origin}`;\n case \"invalid_union\":\n return \"\\u0413\\u0440\\u0435\\u0448\\u0435\\u043D \\u0432\\u043D\\u0435\\u0441\";\n case \"invalid_element\":\n return `\\u0413\\u0440\\u0435\\u0448\\u043D\\u0430 \\u0432\\u0440\\u0435\\u0434\\u043D\\u043E\\u0441\\u0442 \\u0432\\u043E ${issue2.origin}`;\n default:\n return `\\u0413\\u0440\\u0435\\u0448\\u0435\\u043D \\u0432\\u043D\\u0435\\u0441`;\n }\n };\n };\n function mk_default() {\n return {\n localeError: error27()\n };\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/ms.js\n var error28 = () => {\n const Sizable = {\n string: { unit: \"aksara\", verb: \"mempunyai\" },\n file: { unit: \"bait\", verb: \"mempunyai\" },\n array: { unit: \"elemen\", verb: \"mempunyai\" },\n set: { unit: \"elemen\", verb: \"mempunyai\" }\n };\n function getSizing(origin) {\n return Sizable[origin] ?? null;\n }\n const FormatDictionary = {\n regex: \"input\",\n email: \"alamat e-mel\",\n url: \"URL\",\n emoji: \"emoji\",\n uuid: \"UUID\",\n uuidv4: \"UUIDv4\",\n uuidv6: \"UUIDv6\",\n nanoid: \"nanoid\",\n guid: \"GUID\",\n cuid: \"cuid\",\n cuid2: \"cuid2\",\n ulid: \"ULID\",\n xid: \"XID\",\n ksuid: \"KSUID\",\n datetime: \"tarikh masa ISO\",\n date: \"tarikh ISO\",\n time: \"masa ISO\",\n duration: \"tempoh ISO\",\n ipv4: \"alamat IPv4\",\n ipv6: \"alamat IPv6\",\n cidrv4: \"julat IPv4\",\n cidrv6: \"julat IPv6\",\n base64: \"string dikodkan base64\",\n base64url: \"string dikodkan base64url\",\n json_string: \"string JSON\",\n e164: \"nombor E.164\",\n jwt: \"JWT\",\n template_literal: \"input\"\n };\n const TypeDictionary = {\n nan: \"NaN\",\n number: \"nombor\"\n };\n return (issue2) => {\n switch (issue2.code) {\n case \"invalid_type\": {\n const expected = TypeDictionary[issue2.expected] ?? issue2.expected;\n const receivedType = parsedType(issue2.input);\n const received = TypeDictionary[receivedType] ?? receivedType;\n if (/^[A-Z]/.test(issue2.expected)) {\n return `Input tidak sah: dijangka instanceof ${issue2.expected}, diterima ${received}`;\n }\n return `Input tidak sah: dijangka ${expected}, diterima ${received}`;\n }\n case \"invalid_value\":\n if (issue2.values.length === 1)\n return `Input tidak sah: dijangka ${stringifyPrimitive(issue2.values[0])}`;\n return `Pilihan tidak sah: dijangka salah satu daripada ${joinValues(issue2.values, \"|\")}`;\n case \"too_big\": {\n const adj = issue2.inclusive ? \"<=\" : \"<\";\n const sizing = getSizing(issue2.origin);\n if (sizing)\n return `Terlalu besar: dijangka ${issue2.origin ?? \"nilai\"} ${sizing.verb} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? \"elemen\"}`;\n return `Terlalu besar: dijangka ${issue2.origin ?? \"nilai\"} adalah ${adj}${issue2.maximum.toString()}`;\n }\n case \"too_small\": {\n const adj = issue2.inclusive ? \">=\" : \">\";\n const sizing = getSizing(issue2.origin);\n if (sizing) {\n return `Terlalu kecil: dijangka ${issue2.origin} ${sizing.verb} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;\n }\n return `Terlalu kecil: dijangka ${issue2.origin} adalah ${adj}${issue2.minimum.toString()}`;\n }\n case \"invalid_format\": {\n const _issue = issue2;\n if (_issue.format === \"starts_with\")\n return `String tidak sah: mesti bermula dengan \"${_issue.prefix}\"`;\n if (_issue.format === \"ends_with\")\n return `String tidak sah: mesti berakhir dengan \"${_issue.suffix}\"`;\n if (_issue.format === \"includes\")\n return `String tidak sah: mesti mengandungi \"${_issue.includes}\"`;\n if (_issue.format === \"regex\")\n return `String tidak sah: mesti sepadan dengan corak ${_issue.pattern}`;\n return `${FormatDictionary[_issue.format] ?? issue2.format} tidak sah`;\n }\n case \"not_multiple_of\":\n return `Nombor tidak sah: perlu gandaan ${issue2.divisor}`;\n case \"unrecognized_keys\":\n return `Kunci tidak dikenali: ${joinValues(issue2.keys, \", \")}`;\n case \"invalid_key\":\n return `Kunci tidak sah dalam ${issue2.origin}`;\n case \"invalid_union\":\n return \"Input tidak sah\";\n case \"invalid_element\":\n return `Nilai tidak sah dalam ${issue2.origin}`;\n default:\n return `Input tidak sah`;\n }\n };\n };\n function ms_default() {\n return {\n localeError: error28()\n };\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/nl.js\n var error29 = () => {\n const Sizable = {\n string: { unit: \"tekens\", verb: \"heeft\" },\n file: { unit: \"bytes\", verb: \"heeft\" },\n array: { unit: \"elementen\", verb: \"heeft\" },\n set: { unit: \"elementen\", verb: \"heeft\" }\n };\n function getSizing(origin) {\n return Sizable[origin] ?? null;\n }\n const FormatDictionary = {\n regex: \"invoer\",\n email: \"emailadres\",\n url: \"URL\",\n emoji: \"emoji\",\n uuid: \"UUID\",\n uuidv4: \"UUIDv4\",\n uuidv6: \"UUIDv6\",\n nanoid: \"nanoid\",\n guid: \"GUID\",\n cuid: \"cuid\",\n cuid2: \"cuid2\",\n ulid: \"ULID\",\n xid: \"XID\",\n ksuid: \"KSUID\",\n datetime: \"ISO datum en tijd\",\n date: \"ISO datum\",\n time: \"ISO tijd\",\n duration: \"ISO duur\",\n ipv4: \"IPv4-adres\",\n ipv6: \"IPv6-adres\",\n cidrv4: \"IPv4-bereik\",\n cidrv6: \"IPv6-bereik\",\n base64: \"base64-gecodeerde tekst\",\n base64url: \"base64 URL-gecodeerde tekst\",\n json_string: \"JSON string\",\n e164: \"E.164-nummer\",\n jwt: \"JWT\",\n template_literal: \"invoer\"\n };\n const TypeDictionary = {\n nan: \"NaN\",\n number: \"getal\"\n };\n return (issue2) => {\n switch (issue2.code) {\n case \"invalid_type\": {\n const expected = TypeDictionary[issue2.expected] ?? issue2.expected;\n const receivedType = parsedType(issue2.input);\n const received = TypeDictionary[receivedType] ?? receivedType;\n if (/^[A-Z]/.test(issue2.expected)) {\n return `Ongeldige invoer: verwacht instanceof ${issue2.expected}, ontving ${received}`;\n }\n return `Ongeldige invoer: verwacht ${expected}, ontving ${received}`;\n }\n case \"invalid_value\":\n if (issue2.values.length === 1)\n return `Ongeldige invoer: verwacht ${stringifyPrimitive(issue2.values[0])}`;\n return `Ongeldige optie: verwacht \\xE9\\xE9n van ${joinValues(issue2.values, \"|\")}`;\n case \"too_big\": {\n const adj = issue2.inclusive ? \"<=\" : \"<\";\n const sizing = getSizing(issue2.origin);\n const longName = issue2.origin === \"date\" ? \"laat\" : issue2.origin === \"string\" ? \"lang\" : \"groot\";\n if (sizing)\n return `Te ${longName}: verwacht dat ${issue2.origin ?? \"waarde\"} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? \"elementen\"} ${sizing.verb}`;\n return `Te ${longName}: verwacht dat ${issue2.origin ?? \"waarde\"} ${adj}${issue2.maximum.toString()} is`;\n }\n case \"too_small\": {\n const adj = issue2.inclusive ? \">=\" : \">\";\n const sizing = getSizing(issue2.origin);\n const shortName = issue2.origin === \"date\" ? \"vroeg\" : issue2.origin === \"string\" ? \"kort\" : \"klein\";\n if (sizing) {\n return `Te ${shortName}: verwacht dat ${issue2.origin} ${adj}${issue2.minimum.toString()} ${sizing.unit} ${sizing.verb}`;\n }\n return `Te ${shortName}: verwacht dat ${issue2.origin} ${adj}${issue2.minimum.toString()} is`;\n }\n case \"invalid_format\": {\n const _issue = issue2;\n if (_issue.format === \"starts_with\") {\n return `Ongeldige tekst: moet met \"${_issue.prefix}\" beginnen`;\n }\n if (_issue.format === \"ends_with\")\n return `Ongeldige tekst: moet op \"${_issue.suffix}\" eindigen`;\n if (_issue.format === \"includes\")\n return `Ongeldige tekst: moet \"${_issue.includes}\" bevatten`;\n if (_issue.format === \"regex\")\n return `Ongeldige tekst: moet overeenkomen met patroon ${_issue.pattern}`;\n return `Ongeldig: ${FormatDictionary[_issue.format] ?? issue2.format}`;\n }\n case \"not_multiple_of\":\n return `Ongeldig getal: moet een veelvoud van ${issue2.divisor} zijn`;\n case \"unrecognized_keys\":\n return `Onbekende key${issue2.keys.length > 1 ? \"s\" : \"\"}: ${joinValues(issue2.keys, \", \")}`;\n case \"invalid_key\":\n return `Ongeldige key in ${issue2.origin}`;\n case \"invalid_union\":\n return \"Ongeldige invoer\";\n case \"invalid_element\":\n return `Ongeldige waarde in ${issue2.origin}`;\n default:\n return `Ongeldige invoer`;\n }\n };\n };\n function nl_default() {\n return {\n localeError: error29()\n };\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/no.js\n var error30 = () => {\n const Sizable = {\n string: { unit: \"tegn\", verb: \"\\xE5 ha\" },\n file: { unit: \"bytes\", verb: \"\\xE5 ha\" },\n array: { unit: \"elementer\", verb: \"\\xE5 inneholde\" },\n set: { unit: \"elementer\", verb: \"\\xE5 inneholde\" }\n };\n function getSizing(origin) {\n return Sizable[origin] ?? null;\n }\n const FormatDictionary = {\n regex: \"input\",\n email: \"e-postadresse\",\n url: \"URL\",\n emoji: \"emoji\",\n uuid: \"UUID\",\n uuidv4: \"UUIDv4\",\n uuidv6: \"UUIDv6\",\n nanoid: \"nanoid\",\n guid: \"GUID\",\n cuid: \"cuid\",\n cuid2: \"cuid2\",\n ulid: \"ULID\",\n xid: \"XID\",\n ksuid: \"KSUID\",\n datetime: \"ISO dato- og klokkeslett\",\n date: \"ISO-dato\",\n time: \"ISO-klokkeslett\",\n duration: \"ISO-varighet\",\n ipv4: \"IPv4-omr\\xE5de\",\n ipv6: \"IPv6-omr\\xE5de\",\n cidrv4: \"IPv4-spekter\",\n cidrv6: \"IPv6-spekter\",\n base64: \"base64-enkodet streng\",\n base64url: \"base64url-enkodet streng\",\n json_string: \"JSON-streng\",\n e164: \"E.164-nummer\",\n jwt: \"JWT\",\n template_literal: \"input\"\n };\n const TypeDictionary = {\n nan: \"NaN\",\n number: \"tall\",\n array: \"liste\"\n };\n return (issue2) => {\n switch (issue2.code) {\n case \"invalid_type\": {\n const expected = TypeDictionary[issue2.expected] ?? issue2.expected;\n const receivedType = parsedType(issue2.input);\n const received = TypeDictionary[receivedType] ?? receivedType;\n if (/^[A-Z]/.test(issue2.expected)) {\n return `Ugyldig input: forventet instanceof ${issue2.expected}, fikk ${received}`;\n }\n return `Ugyldig input: forventet ${expected}, fikk ${received}`;\n }\n case \"invalid_value\":\n if (issue2.values.length === 1)\n return `Ugyldig verdi: forventet ${stringifyPrimitive(issue2.values[0])}`;\n return `Ugyldig valg: forventet en av ${joinValues(issue2.values, \"|\")}`;\n case \"too_big\": {\n const adj = issue2.inclusive ? \"<=\" : \"<\";\n const sizing = getSizing(issue2.origin);\n if (sizing)\n return `For stor(t): forventet ${issue2.origin ?? \"value\"} til \\xE5 ha ${adj}${issue2.maximum.toString()} ${sizing.unit ?? \"elementer\"}`;\n return `For stor(t): forventet ${issue2.origin ?? \"value\"} til \\xE5 ha ${adj}${issue2.maximum.toString()}`;\n }\n case \"too_small\": {\n const adj = issue2.inclusive ? \">=\" : \">\";\n const sizing = getSizing(issue2.origin);\n if (sizing) {\n return `For lite(n): forventet ${issue2.origin} til \\xE5 ha ${adj}${issue2.minimum.toString()} ${sizing.unit}`;\n }\n return `For lite(n): forventet ${issue2.origin} til \\xE5 ha ${adj}${issue2.minimum.toString()}`;\n }\n case \"invalid_format\": {\n const _issue = issue2;\n if (_issue.format === \"starts_with\")\n return `Ugyldig streng: m\\xE5 starte med \"${_issue.prefix}\"`;\n if (_issue.format === \"ends_with\")\n return `Ugyldig streng: m\\xE5 ende med \"${_issue.suffix}\"`;\n if (_issue.format === \"includes\")\n return `Ugyldig streng: m\\xE5 inneholde \"${_issue.includes}\"`;\n if (_issue.format === \"regex\")\n return `Ugyldig streng: m\\xE5 matche m\\xF8nsteret ${_issue.pattern}`;\n return `Ugyldig ${FormatDictionary[_issue.format] ?? issue2.format}`;\n }\n case \"not_multiple_of\":\n return `Ugyldig tall: m\\xE5 v\\xE6re et multiplum av ${issue2.divisor}`;\n case \"unrecognized_keys\":\n return `${issue2.keys.length > 1 ? \"Ukjente n\\xF8kler\" : \"Ukjent n\\xF8kkel\"}: ${joinValues(issue2.keys, \", \")}`;\n case \"invalid_key\":\n return `Ugyldig n\\xF8kkel i ${issue2.origin}`;\n case \"invalid_union\":\n return \"Ugyldig input\";\n case \"invalid_element\":\n return `Ugyldig verdi i ${issue2.origin}`;\n default:\n return `Ugyldig input`;\n }\n };\n };\n function no_default() {\n return {\n localeError: error30()\n };\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/ota.js\n var error31 = () => {\n const Sizable = {\n string: { unit: \"harf\", verb: \"olmal\\u0131d\\u0131r\" },\n file: { unit: \"bayt\", verb: \"olmal\\u0131d\\u0131r\" },\n array: { unit: \"unsur\", verb: \"olmal\\u0131d\\u0131r\" },\n set: { unit: \"unsur\", verb: \"olmal\\u0131d\\u0131r\" }\n };\n function getSizing(origin) {\n return Sizable[origin] ?? null;\n }\n const FormatDictionary = {\n regex: \"giren\",\n email: \"epostag\\xE2h\",\n url: \"URL\",\n emoji: \"emoji\",\n uuid: \"UUID\",\n uuidv4: \"UUIDv4\",\n uuidv6: \"UUIDv6\",\n nanoid: \"nanoid\",\n guid: \"GUID\",\n cuid: \"cuid\",\n cuid2: \"cuid2\",\n ulid: \"ULID\",\n xid: \"XID\",\n ksuid: \"KSUID\",\n datetime: \"ISO heng\\xE2m\\u0131\",\n date: \"ISO tarihi\",\n time: \"ISO zaman\\u0131\",\n duration: \"ISO m\\xFCddeti\",\n ipv4: \"IPv4 ni\\u015F\\xE2n\\u0131\",\n ipv6: \"IPv6 ni\\u015F\\xE2n\\u0131\",\n cidrv4: \"IPv4 menzili\",\n cidrv6: \"IPv6 menzili\",\n base64: \"base64-\\u015Fifreli metin\",\n base64url: \"base64url-\\u015Fifreli metin\",\n json_string: \"JSON metin\",\n e164: \"E.164 say\\u0131s\\u0131\",\n jwt: \"JWT\",\n template_literal: \"giren\"\n };\n const TypeDictionary = {\n nan: \"NaN\",\n number: \"numara\",\n array: \"saf\",\n null: \"gayb\"\n };\n return (issue2) => {\n switch (issue2.code) {\n case \"invalid_type\": {\n const expected = TypeDictionary[issue2.expected] ?? issue2.expected;\n const receivedType = parsedType(issue2.input);\n const received = TypeDictionary[receivedType] ?? receivedType;\n if (/^[A-Z]/.test(issue2.expected)) {\n return `F\\xE2sit giren: umulan instanceof ${issue2.expected}, al\\u0131nan ${received}`;\n }\n return `F\\xE2sit giren: umulan ${expected}, al\\u0131nan ${received}`;\n }\n case \"invalid_value\":\n if (issue2.values.length === 1)\n return `F\\xE2sit giren: umulan ${stringifyPrimitive(issue2.values[0])}`;\n return `F\\xE2sit tercih: m\\xFBteberler ${joinValues(issue2.values, \"|\")}`;\n case \"too_big\": {\n const adj = issue2.inclusive ? \"<=\" : \"<\";\n const sizing = getSizing(issue2.origin);\n if (sizing)\n return `Fazla b\\xFCy\\xFCk: ${issue2.origin ?? \"value\"}, ${adj}${issue2.maximum.toString()} ${sizing.unit ?? \"elements\"} sahip olmal\\u0131yd\\u0131.`;\n return `Fazla b\\xFCy\\xFCk: ${issue2.origin ?? \"value\"}, ${adj}${issue2.maximum.toString()} olmal\\u0131yd\\u0131.`;\n }\n case \"too_small\": {\n const adj = issue2.inclusive ? \">=\" : \">\";\n const sizing = getSizing(issue2.origin);\n if (sizing) {\n return `Fazla k\\xFC\\xE7\\xFCk: ${issue2.origin}, ${adj}${issue2.minimum.toString()} ${sizing.unit} sahip olmal\\u0131yd\\u0131.`;\n }\n return `Fazla k\\xFC\\xE7\\xFCk: ${issue2.origin}, ${adj}${issue2.minimum.toString()} olmal\\u0131yd\\u0131.`;\n }\n case \"invalid_format\": {\n const _issue = issue2;\n if (_issue.format === \"starts_with\")\n return `F\\xE2sit metin: \"${_issue.prefix}\" ile ba\\u015Flamal\\u0131.`;\n if (_issue.format === \"ends_with\")\n return `F\\xE2sit metin: \"${_issue.suffix}\" ile bitmeli.`;\n if (_issue.format === \"includes\")\n return `F\\xE2sit metin: \"${_issue.includes}\" ihtiv\\xE2 etmeli.`;\n if (_issue.format === \"regex\")\n return `F\\xE2sit metin: ${_issue.pattern} nak\\u015F\\u0131na uymal\\u0131.`;\n return `F\\xE2sit ${FormatDictionary[_issue.format] ?? issue2.format}`;\n }\n case \"not_multiple_of\":\n return `F\\xE2sit say\\u0131: ${issue2.divisor} kat\\u0131 olmal\\u0131yd\\u0131.`;\n case \"unrecognized_keys\":\n return `Tan\\u0131nmayan anahtar ${issue2.keys.length > 1 ? \"s\" : \"\"}: ${joinValues(issue2.keys, \", \")}`;\n case \"invalid_key\":\n return `${issue2.origin} i\\xE7in tan\\u0131nmayan anahtar var.`;\n case \"invalid_union\":\n return \"Giren tan\\u0131namad\\u0131.\";\n case \"invalid_element\":\n return `${issue2.origin} i\\xE7in tan\\u0131nmayan k\\u0131ymet var.`;\n default:\n return `K\\u0131ymet tan\\u0131namad\\u0131.`;\n }\n };\n };\n function ota_default() {\n return {\n localeError: error31()\n };\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/ps.js\n var error32 = () => {\n const Sizable = {\n string: { unit: \"\\u062A\\u0648\\u06A9\\u064A\", verb: \"\\u0648\\u0644\\u0631\\u064A\" },\n file: { unit: \"\\u0628\\u0627\\u06CC\\u067C\\u0633\", verb: \"\\u0648\\u0644\\u0631\\u064A\" },\n array: { unit: \"\\u062A\\u0648\\u06A9\\u064A\", verb: \"\\u0648\\u0644\\u0631\\u064A\" },\n set: { unit: \"\\u062A\\u0648\\u06A9\\u064A\", verb: \"\\u0648\\u0644\\u0631\\u064A\" }\n };\n function getSizing(origin) {\n return Sizable[origin] ?? null;\n }\n const FormatDictionary = {\n regex: \"\\u0648\\u0631\\u0648\\u062F\\u064A\",\n email: \"\\u0628\\u0631\\u06CC\\u069A\\u0646\\u0627\\u0644\\u06CC\\u06A9\",\n url: \"\\u06CC\\u0648 \\u0622\\u0631 \\u0627\\u0644\",\n emoji: \"\\u0627\\u06CC\\u0645\\u0648\\u062C\\u064A\",\n uuid: \"UUID\",\n uuidv4: \"UUIDv4\",\n uuidv6: \"UUIDv6\",\n nanoid: \"nanoid\",\n guid: \"GUID\",\n cuid: \"cuid\",\n cuid2: \"cuid2\",\n ulid: \"ULID\",\n xid: \"XID\",\n ksuid: \"KSUID\",\n datetime: \"\\u0646\\u06CC\\u067C\\u0647 \\u0627\\u0648 \\u0648\\u062E\\u062A\",\n date: \"\\u0646\\u06D0\\u067C\\u0647\",\n time: \"\\u0648\\u062E\\u062A\",\n duration: \"\\u0645\\u0648\\u062F\\u0647\",\n ipv4: \"\\u062F IPv4 \\u067E\\u062A\\u0647\",\n ipv6: \"\\u062F IPv6 \\u067E\\u062A\\u0647\",\n cidrv4: \"\\u062F IPv4 \\u0633\\u0627\\u062D\\u0647\",\n cidrv6: \"\\u062F IPv6 \\u0633\\u0627\\u062D\\u0647\",\n base64: \"base64-encoded \\u0645\\u062A\\u0646\",\n base64url: \"base64url-encoded \\u0645\\u062A\\u0646\",\n json_string: \"JSON \\u0645\\u062A\\u0646\",\n e164: \"\\u062F E.164 \\u0634\\u0645\\u06D0\\u0631\\u0647\",\n jwt: \"JWT\",\n template_literal: \"\\u0648\\u0631\\u0648\\u062F\\u064A\"\n };\n const TypeDictionary = {\n nan: \"NaN\",\n number: \"\\u0639\\u062F\\u062F\",\n array: \"\\u0627\\u0631\\u06D0\"\n };\n return (issue2) => {\n switch (issue2.code) {\n case \"invalid_type\": {\n const expected = TypeDictionary[issue2.expected] ?? issue2.expected;\n const receivedType = parsedType(issue2.input);\n const received = TypeDictionary[receivedType] ?? receivedType;\n if (/^[A-Z]/.test(issue2.expected)) {\n return `\\u0646\\u0627\\u0633\\u0645 \\u0648\\u0631\\u0648\\u062F\\u064A: \\u0628\\u0627\\u06CC\\u062F instanceof ${issue2.expected} \\u0648\\u0627\\u06CC, \\u0645\\u06AB\\u0631 ${received} \\u062A\\u0631\\u0644\\u0627\\u0633\\u0647 \\u0634\\u0648`;\n }\n return `\\u0646\\u0627\\u0633\\u0645 \\u0648\\u0631\\u0648\\u062F\\u064A: \\u0628\\u0627\\u06CC\\u062F ${expected} \\u0648\\u0627\\u06CC, \\u0645\\u06AB\\u0631 ${received} \\u062A\\u0631\\u0644\\u0627\\u0633\\u0647 \\u0634\\u0648`;\n }\n case \"invalid_value\":\n if (issue2.values.length === 1) {\n return `\\u0646\\u0627\\u0633\\u0645 \\u0648\\u0631\\u0648\\u062F\\u064A: \\u0628\\u0627\\u06CC\\u062F ${stringifyPrimitive(issue2.values[0])} \\u0648\\u0627\\u06CC`;\n }\n return `\\u0646\\u0627\\u0633\\u0645 \\u0627\\u0646\\u062A\\u062E\\u0627\\u0628: \\u0628\\u0627\\u06CC\\u062F \\u06CC\\u0648 \\u0644\\u0647 ${joinValues(issue2.values, \"|\")} \\u0685\\u062E\\u0647 \\u0648\\u0627\\u06CC`;\n case \"too_big\": {\n const adj = issue2.inclusive ? \"<=\" : \"<\";\n const sizing = getSizing(issue2.origin);\n if (sizing) {\n return `\\u0689\\u06CC\\u0631 \\u0644\\u0648\\u06CC: ${issue2.origin ?? \"\\u0627\\u0631\\u0632\\u069A\\u062A\"} \\u0628\\u0627\\u06CC\\u062F ${adj}${issue2.maximum.toString()} ${sizing.unit ?? \"\\u0639\\u0646\\u0635\\u0631\\u0648\\u0646\\u0647\"} \\u0648\\u0644\\u0631\\u064A`;\n }\n return `\\u0689\\u06CC\\u0631 \\u0644\\u0648\\u06CC: ${issue2.origin ?? \"\\u0627\\u0631\\u0632\\u069A\\u062A\"} \\u0628\\u0627\\u06CC\\u062F ${adj}${issue2.maximum.toString()} \\u0648\\u064A`;\n }\n case \"too_small\": {\n const adj = issue2.inclusive ? \">=\" : \">\";\n const sizing = getSizing(issue2.origin);\n if (sizing) {\n return `\\u0689\\u06CC\\u0631 \\u06A9\\u0648\\u0686\\u0646\\u06CC: ${issue2.origin} \\u0628\\u0627\\u06CC\\u062F ${adj}${issue2.minimum.toString()} ${sizing.unit} \\u0648\\u0644\\u0631\\u064A`;\n }\n return `\\u0689\\u06CC\\u0631 \\u06A9\\u0648\\u0686\\u0646\\u06CC: ${issue2.origin} \\u0628\\u0627\\u06CC\\u062F ${adj}${issue2.minimum.toString()} \\u0648\\u064A`;\n }\n case \"invalid_format\": {\n const _issue = issue2;\n if (_issue.format === \"starts_with\") {\n return `\\u0646\\u0627\\u0633\\u0645 \\u0645\\u062A\\u0646: \\u0628\\u0627\\u06CC\\u062F \\u062F \"${_issue.prefix}\" \\u0633\\u0631\\u0647 \\u067E\\u06CC\\u0644 \\u0634\\u064A`;\n }\n if (_issue.format === \"ends_with\") {\n return `\\u0646\\u0627\\u0633\\u0645 \\u0645\\u062A\\u0646: \\u0628\\u0627\\u06CC\\u062F \\u062F \"${_issue.suffix}\" \\u0633\\u0631\\u0647 \\u067E\\u0627\\u06CC \\u062A\\u0647 \\u0648\\u0631\\u0633\\u064A\\u0696\\u064A`;\n }\n if (_issue.format === \"includes\") {\n return `\\u0646\\u0627\\u0633\\u0645 \\u0645\\u062A\\u0646: \\u0628\\u0627\\u06CC\\u062F \"${_issue.includes}\" \\u0648\\u0644\\u0631\\u064A`;\n }\n if (_issue.format === \"regex\") {\n return `\\u0646\\u0627\\u0633\\u0645 \\u0645\\u062A\\u0646: \\u0628\\u0627\\u06CC\\u062F \\u062F ${_issue.pattern} \\u0633\\u0631\\u0647 \\u0645\\u0637\\u0627\\u0628\\u0642\\u062A \\u0648\\u0644\\u0631\\u064A`;\n }\n return `${FormatDictionary[_issue.format] ?? issue2.format} \\u0646\\u0627\\u0633\\u0645 \\u062F\\u06CC`;\n }\n case \"not_multiple_of\":\n return `\\u0646\\u0627\\u0633\\u0645 \\u0639\\u062F\\u062F: \\u0628\\u0627\\u06CC\\u062F \\u062F ${issue2.divisor} \\u0645\\u0636\\u0631\\u0628 \\u0648\\u064A`;\n case \"unrecognized_keys\":\n return `\\u0646\\u0627\\u0633\\u0645 ${issue2.keys.length > 1 ? \"\\u06A9\\u0644\\u06CC\\u0689\\u0648\\u0646\\u0647\" : \"\\u06A9\\u0644\\u06CC\\u0689\"}: ${joinValues(issue2.keys, \", \")}`;\n case \"invalid_key\":\n return `\\u0646\\u0627\\u0633\\u0645 \\u06A9\\u0644\\u06CC\\u0689 \\u067E\\u0647 ${issue2.origin} \\u06A9\\u06D0`;\n case \"invalid_union\":\n return `\\u0646\\u0627\\u0633\\u0645\\u0647 \\u0648\\u0631\\u0648\\u062F\\u064A`;\n case \"invalid_element\":\n return `\\u0646\\u0627\\u0633\\u0645 \\u0639\\u0646\\u0635\\u0631 \\u067E\\u0647 ${issue2.origin} \\u06A9\\u06D0`;\n default:\n return `\\u0646\\u0627\\u0633\\u0645\\u0647 \\u0648\\u0631\\u0648\\u062F\\u064A`;\n }\n };\n };\n function ps_default() {\n return {\n localeError: error32()\n };\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/pl.js\n var error33 = () => {\n const Sizable = {\n string: { unit: \"znak\\xF3w\", verb: \"mie\\u0107\" },\n file: { unit: \"bajt\\xF3w\", verb: \"mie\\u0107\" },\n array: { unit: \"element\\xF3w\", verb: \"mie\\u0107\" },\n set: { unit: \"element\\xF3w\", verb: \"mie\\u0107\" }\n };\n function getSizing(origin) {\n return Sizable[origin] ?? null;\n }\n const FormatDictionary = {\n regex: \"wyra\\u017Cenie\",\n email: \"adres email\",\n url: \"URL\",\n emoji: \"emoji\",\n uuid: \"UUID\",\n uuidv4: \"UUIDv4\",\n uuidv6: \"UUIDv6\",\n nanoid: \"nanoid\",\n guid: \"GUID\",\n cuid: \"cuid\",\n cuid2: \"cuid2\",\n ulid: \"ULID\",\n xid: \"XID\",\n ksuid: \"KSUID\",\n datetime: \"data i godzina w formacie ISO\",\n date: \"data w formacie ISO\",\n time: \"godzina w formacie ISO\",\n duration: \"czas trwania ISO\",\n ipv4: \"adres IPv4\",\n ipv6: \"adres IPv6\",\n cidrv4: \"zakres IPv4\",\n cidrv6: \"zakres IPv6\",\n base64: \"ci\\u0105g znak\\xF3w zakodowany w formacie base64\",\n base64url: \"ci\\u0105g znak\\xF3w zakodowany w formacie base64url\",\n json_string: \"ci\\u0105g znak\\xF3w w formacie JSON\",\n e164: \"liczba E.164\",\n jwt: \"JWT\",\n template_literal: \"wej\\u015Bcie\"\n };\n const TypeDictionary = {\n nan: \"NaN\",\n number: \"liczba\",\n array: \"tablica\"\n };\n return (issue2) => {\n switch (issue2.code) {\n case \"invalid_type\": {\n const expected = TypeDictionary[issue2.expected] ?? issue2.expected;\n const receivedType = parsedType(issue2.input);\n const received = TypeDictionary[receivedType] ?? receivedType;\n if (/^[A-Z]/.test(issue2.expected)) {\n return `Nieprawid\\u0142owe dane wej\\u015Bciowe: oczekiwano instanceof ${issue2.expected}, otrzymano ${received}`;\n }\n return `Nieprawid\\u0142owe dane wej\\u015Bciowe: oczekiwano ${expected}, otrzymano ${received}`;\n }\n case \"invalid_value\":\n if (issue2.values.length === 1)\n return `Nieprawid\\u0142owe dane wej\\u015Bciowe: oczekiwano ${stringifyPrimitive(issue2.values[0])}`;\n return `Nieprawid\\u0142owa opcja: oczekiwano jednej z warto\\u015Bci ${joinValues(issue2.values, \"|\")}`;\n case \"too_big\": {\n const adj = issue2.inclusive ? \"<=\" : \"<\";\n const sizing = getSizing(issue2.origin);\n if (sizing) {\n return `Za du\\u017Ca warto\\u015B\\u0107: oczekiwano, \\u017Ce ${issue2.origin ?? \"warto\\u015B\\u0107\"} b\\u0119dzie mie\\u0107 ${adj}${issue2.maximum.toString()} ${sizing.unit ?? \"element\\xF3w\"}`;\n }\n return `Zbyt du\\u017C(y/a/e): oczekiwano, \\u017Ce ${issue2.origin ?? \"warto\\u015B\\u0107\"} b\\u0119dzie wynosi\\u0107 ${adj}${issue2.maximum.toString()}`;\n }\n case \"too_small\": {\n const adj = issue2.inclusive ? \">=\" : \">\";\n const sizing = getSizing(issue2.origin);\n if (sizing) {\n return `Za ma\\u0142a warto\\u015B\\u0107: oczekiwano, \\u017Ce ${issue2.origin ?? \"warto\\u015B\\u0107\"} b\\u0119dzie mie\\u0107 ${adj}${issue2.minimum.toString()} ${sizing.unit ?? \"element\\xF3w\"}`;\n }\n return `Zbyt ma\\u0142(y/a/e): oczekiwano, \\u017Ce ${issue2.origin ?? \"warto\\u015B\\u0107\"} b\\u0119dzie wynosi\\u0107 ${adj}${issue2.minimum.toString()}`;\n }\n case \"invalid_format\": {\n const _issue = issue2;\n if (_issue.format === \"starts_with\")\n return `Nieprawid\\u0142owy ci\\u0105g znak\\xF3w: musi zaczyna\\u0107 si\\u0119 od \"${_issue.prefix}\"`;\n if (_issue.format === \"ends_with\")\n return `Nieprawid\\u0142owy ci\\u0105g znak\\xF3w: musi ko\\u0144czy\\u0107 si\\u0119 na \"${_issue.suffix}\"`;\n if (_issue.format === \"includes\")\n return `Nieprawid\\u0142owy ci\\u0105g znak\\xF3w: musi zawiera\\u0107 \"${_issue.includes}\"`;\n if (_issue.format === \"regex\")\n return `Nieprawid\\u0142owy ci\\u0105g znak\\xF3w: musi odpowiada\\u0107 wzorcowi ${_issue.pattern}`;\n return `Nieprawid\\u0142ow(y/a/e) ${FormatDictionary[_issue.format] ?? issue2.format}`;\n }\n case \"not_multiple_of\":\n return `Nieprawid\\u0142owa liczba: musi by\\u0107 wielokrotno\\u015Bci\\u0105 ${issue2.divisor}`;\n case \"unrecognized_keys\":\n return `Nierozpoznane klucze${issue2.keys.length > 1 ? \"s\" : \"\"}: ${joinValues(issue2.keys, \", \")}`;\n case \"invalid_key\":\n return `Nieprawid\\u0142owy klucz w ${issue2.origin}`;\n case \"invalid_union\":\n return \"Nieprawid\\u0142owe dane wej\\u015Bciowe\";\n case \"invalid_element\":\n return `Nieprawid\\u0142owa warto\\u015B\\u0107 w ${issue2.origin}`;\n default:\n return `Nieprawid\\u0142owe dane wej\\u015Bciowe`;\n }\n };\n };\n function pl_default() {\n return {\n localeError: error33()\n };\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/pt.js\n var error34 = () => {\n const Sizable = {\n string: { unit: \"caracteres\", verb: \"ter\" },\n file: { unit: \"bytes\", verb: \"ter\" },\n array: { unit: \"itens\", verb: \"ter\" },\n set: { unit: \"itens\", verb: \"ter\" }\n };\n function getSizing(origin) {\n return Sizable[origin] ?? null;\n }\n const FormatDictionary = {\n regex: \"padr\\xE3o\",\n email: \"endere\\xE7o de e-mail\",\n url: \"URL\",\n emoji: \"emoji\",\n uuid: \"UUID\",\n uuidv4: \"UUIDv4\",\n uuidv6: \"UUIDv6\",\n nanoid: \"nanoid\",\n guid: \"GUID\",\n cuid: \"cuid\",\n cuid2: \"cuid2\",\n ulid: \"ULID\",\n xid: \"XID\",\n ksuid: \"KSUID\",\n datetime: \"data e hora ISO\",\n date: \"data ISO\",\n time: \"hora ISO\",\n duration: \"dura\\xE7\\xE3o ISO\",\n ipv4: \"endere\\xE7o IPv4\",\n ipv6: \"endere\\xE7o IPv6\",\n cidrv4: \"faixa de IPv4\",\n cidrv6: \"faixa de IPv6\",\n base64: \"texto codificado em base64\",\n base64url: \"URL codificada em base64\",\n json_string: \"texto JSON\",\n e164: \"n\\xFAmero E.164\",\n jwt: \"JWT\",\n template_literal: \"entrada\"\n };\n const TypeDictionary = {\n nan: \"NaN\",\n number: \"n\\xFAmero\",\n null: \"nulo\"\n };\n return (issue2) => {\n switch (issue2.code) {\n case \"invalid_type\": {\n const expected = TypeDictionary[issue2.expected] ?? issue2.expected;\n const receivedType = parsedType(issue2.input);\n const received = TypeDictionary[receivedType] ?? receivedType;\n if (/^[A-Z]/.test(issue2.expected)) {\n return `Tipo inv\\xE1lido: esperado instanceof ${issue2.expected}, recebido ${received}`;\n }\n return `Tipo inv\\xE1lido: esperado ${expected}, recebido ${received}`;\n }\n case \"invalid_value\":\n if (issue2.values.length === 1)\n return `Entrada inv\\xE1lida: esperado ${stringifyPrimitive(issue2.values[0])}`;\n return `Op\\xE7\\xE3o inv\\xE1lida: esperada uma das ${joinValues(issue2.values, \"|\")}`;\n case \"too_big\": {\n const adj = issue2.inclusive ? \"<=\" : \"<\";\n const sizing = getSizing(issue2.origin);\n if (sizing)\n return `Muito grande: esperado que ${issue2.origin ?? \"valor\"} tivesse ${adj}${issue2.maximum.toString()} ${sizing.unit ?? \"elementos\"}`;\n return `Muito grande: esperado que ${issue2.origin ?? \"valor\"} fosse ${adj}${issue2.maximum.toString()}`;\n }\n case \"too_small\": {\n const adj = issue2.inclusive ? \">=\" : \">\";\n const sizing = getSizing(issue2.origin);\n if (sizing) {\n return `Muito pequeno: esperado que ${issue2.origin} tivesse ${adj}${issue2.minimum.toString()} ${sizing.unit}`;\n }\n return `Muito pequeno: esperado que ${issue2.origin} fosse ${adj}${issue2.minimum.toString()}`;\n }\n case \"invalid_format\": {\n const _issue = issue2;\n if (_issue.format === \"starts_with\")\n return `Texto inv\\xE1lido: deve come\\xE7ar com \"${_issue.prefix}\"`;\n if (_issue.format === \"ends_with\")\n return `Texto inv\\xE1lido: deve terminar com \"${_issue.suffix}\"`;\n if (_issue.format === \"includes\")\n return `Texto inv\\xE1lido: deve incluir \"${_issue.includes}\"`;\n if (_issue.format === \"regex\")\n return `Texto inv\\xE1lido: deve corresponder ao padr\\xE3o ${_issue.pattern}`;\n return `${FormatDictionary[_issue.format] ?? issue2.format} inv\\xE1lido`;\n }\n case \"not_multiple_of\":\n return `N\\xFAmero inv\\xE1lido: deve ser m\\xFAltiplo de ${issue2.divisor}`;\n case \"unrecognized_keys\":\n return `Chave${issue2.keys.length > 1 ? \"s\" : \"\"} desconhecida${issue2.keys.length > 1 ? \"s\" : \"\"}: ${joinValues(issue2.keys, \", \")}`;\n case \"invalid_key\":\n return `Chave inv\\xE1lida em ${issue2.origin}`;\n case \"invalid_union\":\n return \"Entrada inv\\xE1lida\";\n case \"invalid_element\":\n return `Valor inv\\xE1lido em ${issue2.origin}`;\n default:\n return `Campo inv\\xE1lido`;\n }\n };\n };\n function pt_default() {\n return {\n localeError: error34()\n };\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/ru.js\n function getRussianPlural(count, one, few, many) {\n const absCount = Math.abs(count);\n const lastDigit = absCount % 10;\n const lastTwoDigits = absCount % 100;\n if (lastTwoDigits >= 11 && lastTwoDigits <= 19) {\n return many;\n }\n if (lastDigit === 1) {\n return one;\n }\n if (lastDigit >= 2 && lastDigit <= 4) {\n return few;\n }\n return many;\n }\n var error35 = () => {\n const Sizable = {\n string: {\n unit: {\n one: \"\\u0441\\u0438\\u043C\\u0432\\u043E\\u043B\",\n few: \"\\u0441\\u0438\\u043C\\u0432\\u043E\\u043B\\u0430\",\n many: \"\\u0441\\u0438\\u043C\\u0432\\u043E\\u043B\\u043E\\u0432\"\n },\n verb: \"\\u0438\\u043C\\u0435\\u0442\\u044C\"\n },\n file: {\n unit: {\n one: \"\\u0431\\u0430\\u0439\\u0442\",\n few: \"\\u0431\\u0430\\u0439\\u0442\\u0430\",\n many: \"\\u0431\\u0430\\u0439\\u0442\"\n },\n verb: \"\\u0438\\u043C\\u0435\\u0442\\u044C\"\n },\n array: {\n unit: {\n one: \"\\u044D\\u043B\\u0435\\u043C\\u0435\\u043D\\u0442\",\n few: \"\\u044D\\u043B\\u0435\\u043C\\u0435\\u043D\\u0442\\u0430\",\n many: \"\\u044D\\u043B\\u0435\\u043C\\u0435\\u043D\\u0442\\u043E\\u0432\"\n },\n verb: \"\\u0438\\u043C\\u0435\\u0442\\u044C\"\n },\n set: {\n unit: {\n one: \"\\u044D\\u043B\\u0435\\u043C\\u0435\\u043D\\u0442\",\n few: \"\\u044D\\u043B\\u0435\\u043C\\u0435\\u043D\\u0442\\u0430\",\n many: \"\\u044D\\u043B\\u0435\\u043C\\u0435\\u043D\\u0442\\u043E\\u0432\"\n },\n verb: \"\\u0438\\u043C\\u0435\\u0442\\u044C\"\n }\n };\n function getSizing(origin) {\n return Sizable[origin] ?? null;\n }\n const FormatDictionary = {\n regex: \"\\u0432\\u0432\\u043E\\u0434\",\n email: \"email \\u0430\\u0434\\u0440\\u0435\\u0441\",\n url: \"URL\",\n emoji: \"\\u044D\\u043C\\u043E\\u0434\\u0437\\u0438\",\n uuid: \"UUID\",\n uuidv4: \"UUIDv4\",\n uuidv6: \"UUIDv6\",\n nanoid: \"nanoid\",\n guid: \"GUID\",\n cuid: \"cuid\",\n cuid2: \"cuid2\",\n ulid: \"ULID\",\n xid: \"XID\",\n ksuid: \"KSUID\",\n datetime: \"ISO \\u0434\\u0430\\u0442\\u0430 \\u0438 \\u0432\\u0440\\u0435\\u043C\\u044F\",\n date: \"ISO \\u0434\\u0430\\u0442\\u0430\",\n time: \"ISO \\u0432\\u0440\\u0435\\u043C\\u044F\",\n duration: \"ISO \\u0434\\u043B\\u0438\\u0442\\u0435\\u043B\\u044C\\u043D\\u043E\\u0441\\u0442\\u044C\",\n ipv4: \"IPv4 \\u0430\\u0434\\u0440\\u0435\\u0441\",\n ipv6: \"IPv6 \\u0430\\u0434\\u0440\\u0435\\u0441\",\n cidrv4: \"IPv4 \\u0434\\u0438\\u0430\\u043F\\u0430\\u0437\\u043E\\u043D\",\n cidrv6: \"IPv6 \\u0434\\u0438\\u0430\\u043F\\u0430\\u0437\\u043E\\u043D\",\n base64: \"\\u0441\\u0442\\u0440\\u043E\\u043A\\u0430 \\u0432 \\u0444\\u043E\\u0440\\u043C\\u0430\\u0442\\u0435 base64\",\n base64url: \"\\u0441\\u0442\\u0440\\u043E\\u043A\\u0430 \\u0432 \\u0444\\u043E\\u0440\\u043C\\u0430\\u0442\\u0435 base64url\",\n json_string: \"JSON \\u0441\\u0442\\u0440\\u043E\\u043A\\u0430\",\n e164: \"\\u043D\\u043E\\u043C\\u0435\\u0440 E.164\",\n jwt: \"JWT\",\n template_literal: \"\\u0432\\u0432\\u043E\\u0434\"\n };\n const TypeDictionary = {\n nan: \"NaN\",\n number: \"\\u0447\\u0438\\u0441\\u043B\\u043E\",\n array: \"\\u043C\\u0430\\u0441\\u0441\\u0438\\u0432\"\n };\n return (issue2) => {\n switch (issue2.code) {\n case \"invalid_type\": {\n const expected = TypeDictionary[issue2.expected] ?? issue2.expected;\n const receivedType = parsedType(issue2.input);\n const received = TypeDictionary[receivedType] ?? receivedType;\n if (/^[A-Z]/.test(issue2.expected)) {\n return `\\u041D\\u0435\\u0432\\u0435\\u0440\\u043D\\u044B\\u0439 \\u0432\\u0432\\u043E\\u0434: \\u043E\\u0436\\u0438\\u0434\\u0430\\u043B\\u043E\\u0441\\u044C instanceof ${issue2.expected}, \\u043F\\u043E\\u043B\\u0443\\u0447\\u0435\\u043D\\u043E ${received}`;\n }\n return `\\u041D\\u0435\\u0432\\u0435\\u0440\\u043D\\u044B\\u0439 \\u0432\\u0432\\u043E\\u0434: \\u043E\\u0436\\u0438\\u0434\\u0430\\u043B\\u043E\\u0441\\u044C ${expected}, \\u043F\\u043E\\u043B\\u0443\\u0447\\u0435\\u043D\\u043E ${received}`;\n }\n case \"invalid_value\":\n if (issue2.values.length === 1)\n return `\\u041D\\u0435\\u0432\\u0435\\u0440\\u043D\\u044B\\u0439 \\u0432\\u0432\\u043E\\u0434: \\u043E\\u0436\\u0438\\u0434\\u0430\\u043B\\u043E\\u0441\\u044C ${stringifyPrimitive(issue2.values[0])}`;\n return `\\u041D\\u0435\\u0432\\u0435\\u0440\\u043D\\u044B\\u0439 \\u0432\\u0430\\u0440\\u0438\\u0430\\u043D\\u0442: \\u043E\\u0436\\u0438\\u0434\\u0430\\u043B\\u043E\\u0441\\u044C \\u043E\\u0434\\u043D\\u043E \\u0438\\u0437 ${joinValues(issue2.values, \"|\")}`;\n case \"too_big\": {\n const adj = issue2.inclusive ? \"<=\" : \"<\";\n const sizing = getSizing(issue2.origin);\n if (sizing) {\n const maxValue = Number(issue2.maximum);\n const unit = getRussianPlural(maxValue, sizing.unit.one, sizing.unit.few, sizing.unit.many);\n return `\\u0421\\u043B\\u0438\\u0448\\u043A\\u043E\\u043C \\u0431\\u043E\\u043B\\u044C\\u0448\\u043E\\u0435 \\u0437\\u043D\\u0430\\u0447\\u0435\\u043D\\u0438\\u0435: \\u043E\\u0436\\u0438\\u0434\\u0430\\u043B\\u043E\\u0441\\u044C, \\u0447\\u0442\\u043E ${issue2.origin ?? \"\\u0437\\u043D\\u0430\\u0447\\u0435\\u043D\\u0438\\u0435\"} \\u0431\\u0443\\u0434\\u0435\\u0442 \\u0438\\u043C\\u0435\\u0442\\u044C ${adj}${issue2.maximum.toString()} ${unit}`;\n }\n return `\\u0421\\u043B\\u0438\\u0448\\u043A\\u043E\\u043C \\u0431\\u043E\\u043B\\u044C\\u0448\\u043E\\u0435 \\u0437\\u043D\\u0430\\u0447\\u0435\\u043D\\u0438\\u0435: \\u043E\\u0436\\u0438\\u0434\\u0430\\u043B\\u043E\\u0441\\u044C, \\u0447\\u0442\\u043E ${issue2.origin ?? \"\\u0437\\u043D\\u0430\\u0447\\u0435\\u043D\\u0438\\u0435\"} \\u0431\\u0443\\u0434\\u0435\\u0442 ${adj}${issue2.maximum.toString()}`;\n }\n case \"too_small\": {\n const adj = issue2.inclusive ? \">=\" : \">\";\n const sizing = getSizing(issue2.origin);\n if (sizing) {\n const minValue = Number(issue2.minimum);\n const unit = getRussianPlural(minValue, sizing.unit.one, sizing.unit.few, sizing.unit.many);\n return `\\u0421\\u043B\\u0438\\u0448\\u043A\\u043E\\u043C \\u043C\\u0430\\u043B\\u0435\\u043D\\u044C\\u043A\\u043E\\u0435 \\u0437\\u043D\\u0430\\u0447\\u0435\\u043D\\u0438\\u0435: \\u043E\\u0436\\u0438\\u0434\\u0430\\u043B\\u043E\\u0441\\u044C, \\u0447\\u0442\\u043E ${issue2.origin} \\u0431\\u0443\\u0434\\u0435\\u0442 \\u0438\\u043C\\u0435\\u0442\\u044C ${adj}${issue2.minimum.toString()} ${unit}`;\n }\n return `\\u0421\\u043B\\u0438\\u0448\\u043A\\u043E\\u043C \\u043C\\u0430\\u043B\\u0435\\u043D\\u044C\\u043A\\u043E\\u0435 \\u0437\\u043D\\u0430\\u0447\\u0435\\u043D\\u0438\\u0435: \\u043E\\u0436\\u0438\\u0434\\u0430\\u043B\\u043E\\u0441\\u044C, \\u0447\\u0442\\u043E ${issue2.origin} \\u0431\\u0443\\u0434\\u0435\\u0442 ${adj}${issue2.minimum.toString()}`;\n }\n case \"invalid_format\": {\n const _issue = issue2;\n if (_issue.format === \"starts_with\")\n return `\\u041D\\u0435\\u0432\\u0435\\u0440\\u043D\\u0430\\u044F \\u0441\\u0442\\u0440\\u043E\\u043A\\u0430: \\u0434\\u043E\\u043B\\u0436\\u043D\\u0430 \\u043D\\u0430\\u0447\\u0438\\u043D\\u0430\\u0442\\u044C\\u0441\\u044F \\u0441 \"${_issue.prefix}\"`;\n if (_issue.format === \"ends_with\")\n return `\\u041D\\u0435\\u0432\\u0435\\u0440\\u043D\\u0430\\u044F \\u0441\\u0442\\u0440\\u043E\\u043A\\u0430: \\u0434\\u043E\\u043B\\u0436\\u043D\\u0430 \\u0437\\u0430\\u043A\\u0430\\u043D\\u0447\\u0438\\u0432\\u0430\\u0442\\u044C\\u0441\\u044F \\u043D\\u0430 \"${_issue.suffix}\"`;\n if (_issue.format === \"includes\")\n return `\\u041D\\u0435\\u0432\\u0435\\u0440\\u043D\\u0430\\u044F \\u0441\\u0442\\u0440\\u043E\\u043A\\u0430: \\u0434\\u043E\\u043B\\u0436\\u043D\\u0430 \\u0441\\u043E\\u0434\\u0435\\u0440\\u0436\\u0430\\u0442\\u044C \"${_issue.includes}\"`;\n if (_issue.format === \"regex\")\n return `\\u041D\\u0435\\u0432\\u0435\\u0440\\u043D\\u0430\\u044F \\u0441\\u0442\\u0440\\u043E\\u043A\\u0430: \\u0434\\u043E\\u043B\\u0436\\u043D\\u0430 \\u0441\\u043E\\u043E\\u0442\\u0432\\u0435\\u0442\\u0441\\u0442\\u0432\\u043E\\u0432\\u0430\\u0442\\u044C \\u0448\\u0430\\u0431\\u043B\\u043E\\u043D\\u0443 ${_issue.pattern}`;\n return `\\u041D\\u0435\\u0432\\u0435\\u0440\\u043D\\u044B\\u0439 ${FormatDictionary[_issue.format] ?? issue2.format}`;\n }\n case \"not_multiple_of\":\n return `\\u041D\\u0435\\u0432\\u0435\\u0440\\u043D\\u043E\\u0435 \\u0447\\u0438\\u0441\\u043B\\u043E: \\u0434\\u043E\\u043B\\u0436\\u043D\\u043E \\u0431\\u044B\\u0442\\u044C \\u043A\\u0440\\u0430\\u0442\\u043D\\u044B\\u043C ${issue2.divisor}`;\n case \"unrecognized_keys\":\n return `\\u041D\\u0435\\u0440\\u0430\\u0441\\u043F\\u043E\\u0437\\u043D\\u0430\\u043D\\u043D${issue2.keys.length > 1 ? \"\\u044B\\u0435\" : \"\\u044B\\u0439\"} \\u043A\\u043B\\u044E\\u0447${issue2.keys.length > 1 ? \"\\u0438\" : \"\"}: ${joinValues(issue2.keys, \", \")}`;\n case \"invalid_key\":\n return `\\u041D\\u0435\\u0432\\u0435\\u0440\\u043D\\u044B\\u0439 \\u043A\\u043B\\u044E\\u0447 \\u0432 ${issue2.origin}`;\n case \"invalid_union\":\n return \"\\u041D\\u0435\\u0432\\u0435\\u0440\\u043D\\u044B\\u0435 \\u0432\\u0445\\u043E\\u0434\\u043D\\u044B\\u0435 \\u0434\\u0430\\u043D\\u043D\\u044B\\u0435\";\n case \"invalid_element\":\n return `\\u041D\\u0435\\u0432\\u0435\\u0440\\u043D\\u043E\\u0435 \\u0437\\u043D\\u0430\\u0447\\u0435\\u043D\\u0438\\u0435 \\u0432 ${issue2.origin}`;\n default:\n return `\\u041D\\u0435\\u0432\\u0435\\u0440\\u043D\\u044B\\u0435 \\u0432\\u0445\\u043E\\u0434\\u043D\\u044B\\u0435 \\u0434\\u0430\\u043D\\u043D\\u044B\\u0435`;\n }\n };\n };\n function ru_default() {\n return {\n localeError: error35()\n };\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/sl.js\n var error36 = () => {\n const Sizable = {\n string: { unit: \"znakov\", verb: \"imeti\" },\n file: { unit: \"bajtov\", verb: \"imeti\" },\n array: { unit: \"elementov\", verb: \"imeti\" },\n set: { unit: \"elementov\", verb: \"imeti\" }\n };\n function getSizing(origin) {\n return Sizable[origin] ?? null;\n }\n const FormatDictionary = {\n regex: \"vnos\",\n email: \"e-po\\u0161tni naslov\",\n url: \"URL\",\n emoji: \"emoji\",\n uuid: \"UUID\",\n uuidv4: \"UUIDv4\",\n uuidv6: \"UUIDv6\",\n nanoid: \"nanoid\",\n guid: \"GUID\",\n cuid: \"cuid\",\n cuid2: \"cuid2\",\n ulid: \"ULID\",\n xid: \"XID\",\n ksuid: \"KSUID\",\n datetime: \"ISO datum in \\u010Das\",\n date: \"ISO datum\",\n time: \"ISO \\u010Das\",\n duration: \"ISO trajanje\",\n ipv4: \"IPv4 naslov\",\n ipv6: \"IPv6 naslov\",\n cidrv4: \"obseg IPv4\",\n cidrv6: \"obseg IPv6\",\n base64: \"base64 kodiran niz\",\n base64url: \"base64url kodiran niz\",\n json_string: \"JSON niz\",\n e164: \"E.164 \\u0161tevilka\",\n jwt: \"JWT\",\n template_literal: \"vnos\"\n };\n const TypeDictionary = {\n nan: \"NaN\",\n number: \"\\u0161tevilo\",\n array: \"tabela\"\n };\n return (issue2) => {\n switch (issue2.code) {\n case \"invalid_type\": {\n const expected = TypeDictionary[issue2.expected] ?? issue2.expected;\n const receivedType = parsedType(issue2.input);\n const received = TypeDictionary[receivedType] ?? receivedType;\n if (/^[A-Z]/.test(issue2.expected)) {\n return `Neveljaven vnos: pri\\u010Dakovano instanceof ${issue2.expected}, prejeto ${received}`;\n }\n return `Neveljaven vnos: pri\\u010Dakovano ${expected}, prejeto ${received}`;\n }\n case \"invalid_value\":\n if (issue2.values.length === 1)\n return `Neveljaven vnos: pri\\u010Dakovano ${stringifyPrimitive(issue2.values[0])}`;\n return `Neveljavna mo\\u017Enost: pri\\u010Dakovano eno izmed ${joinValues(issue2.values, \"|\")}`;\n case \"too_big\": {\n const adj = issue2.inclusive ? \"<=\" : \"<\";\n const sizing = getSizing(issue2.origin);\n if (sizing)\n return `Preveliko: pri\\u010Dakovano, da bo ${issue2.origin ?? \"vrednost\"} imelo ${adj}${issue2.maximum.toString()} ${sizing.unit ?? \"elementov\"}`;\n return `Preveliko: pri\\u010Dakovano, da bo ${issue2.origin ?? \"vrednost\"} ${adj}${issue2.maximum.toString()}`;\n }\n case \"too_small\": {\n const adj = issue2.inclusive ? \">=\" : \">\";\n const sizing = getSizing(issue2.origin);\n if (sizing) {\n return `Premajhno: pri\\u010Dakovano, da bo ${issue2.origin} imelo ${adj}${issue2.minimum.toString()} ${sizing.unit}`;\n }\n return `Premajhno: pri\\u010Dakovano, da bo ${issue2.origin} ${adj}${issue2.minimum.toString()}`;\n }\n case \"invalid_format\": {\n const _issue = issue2;\n if (_issue.format === \"starts_with\") {\n return `Neveljaven niz: mora se za\\u010Deti z \"${_issue.prefix}\"`;\n }\n if (_issue.format === \"ends_with\")\n return `Neveljaven niz: mora se kon\\u010Dati z \"${_issue.suffix}\"`;\n if (_issue.format === \"includes\")\n return `Neveljaven niz: mora vsebovati \"${_issue.includes}\"`;\n if (_issue.format === \"regex\")\n return `Neveljaven niz: mora ustrezati vzorcu ${_issue.pattern}`;\n return `Neveljaven ${FormatDictionary[_issue.format] ?? issue2.format}`;\n }\n case \"not_multiple_of\":\n return `Neveljavno \\u0161tevilo: mora biti ve\\u010Dkratnik ${issue2.divisor}`;\n case \"unrecognized_keys\":\n return `Neprepoznan${issue2.keys.length > 1 ? \"i klju\\u010Di\" : \" klju\\u010D\"}: ${joinValues(issue2.keys, \", \")}`;\n case \"invalid_key\":\n return `Neveljaven klju\\u010D v ${issue2.origin}`;\n case \"invalid_union\":\n return \"Neveljaven vnos\";\n case \"invalid_element\":\n return `Neveljavna vrednost v ${issue2.origin}`;\n default:\n return \"Neveljaven vnos\";\n }\n };\n };\n function sl_default() {\n return {\n localeError: error36()\n };\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/sv.js\n var error37 = () => {\n const Sizable = {\n string: { unit: \"tecken\", verb: \"att ha\" },\n file: { unit: \"bytes\", verb: \"att ha\" },\n array: { unit: \"objekt\", verb: \"att inneh\\xE5lla\" },\n set: { unit: \"objekt\", verb: \"att inneh\\xE5lla\" }\n };\n function getSizing(origin) {\n return Sizable[origin] ?? null;\n }\n const FormatDictionary = {\n regex: \"regulj\\xE4rt uttryck\",\n email: \"e-postadress\",\n url: \"URL\",\n emoji: \"emoji\",\n uuid: \"UUID\",\n uuidv4: \"UUIDv4\",\n uuidv6: \"UUIDv6\",\n nanoid: \"nanoid\",\n guid: \"GUID\",\n cuid: \"cuid\",\n cuid2: \"cuid2\",\n ulid: \"ULID\",\n xid: \"XID\",\n ksuid: \"KSUID\",\n datetime: \"ISO-datum och tid\",\n date: \"ISO-datum\",\n time: \"ISO-tid\",\n duration: \"ISO-varaktighet\",\n ipv4: \"IPv4-intervall\",\n ipv6: \"IPv6-intervall\",\n cidrv4: \"IPv4-spektrum\",\n cidrv6: \"IPv6-spektrum\",\n base64: \"base64-kodad str\\xE4ng\",\n base64url: \"base64url-kodad str\\xE4ng\",\n json_string: \"JSON-str\\xE4ng\",\n e164: \"E.164-nummer\",\n jwt: \"JWT\",\n template_literal: \"mall-literal\"\n };\n const TypeDictionary = {\n nan: \"NaN\",\n number: \"antal\",\n array: \"lista\"\n };\n return (issue2) => {\n switch (issue2.code) {\n case \"invalid_type\": {\n const expected = TypeDictionary[issue2.expected] ?? issue2.expected;\n const receivedType = parsedType(issue2.input);\n const received = TypeDictionary[receivedType] ?? receivedType;\n if (/^[A-Z]/.test(issue2.expected)) {\n return `Ogiltig inmatning: f\\xF6rv\\xE4ntat instanceof ${issue2.expected}, fick ${received}`;\n }\n return `Ogiltig inmatning: f\\xF6rv\\xE4ntat ${expected}, fick ${received}`;\n }\n case \"invalid_value\":\n if (issue2.values.length === 1)\n return `Ogiltig inmatning: f\\xF6rv\\xE4ntat ${stringifyPrimitive(issue2.values[0])}`;\n return `Ogiltigt val: f\\xF6rv\\xE4ntade en av ${joinValues(issue2.values, \"|\")}`;\n case \"too_big\": {\n const adj = issue2.inclusive ? \"<=\" : \"<\";\n const sizing = getSizing(issue2.origin);\n if (sizing) {\n return `F\\xF6r stor(t): f\\xF6rv\\xE4ntade ${issue2.origin ?? \"v\\xE4rdet\"} att ha ${adj}${issue2.maximum.toString()} ${sizing.unit ?? \"element\"}`;\n }\n return `F\\xF6r stor(t): f\\xF6rv\\xE4ntat ${issue2.origin ?? \"v\\xE4rdet\"} att ha ${adj}${issue2.maximum.toString()}`;\n }\n case \"too_small\": {\n const adj = issue2.inclusive ? \">=\" : \">\";\n const sizing = getSizing(issue2.origin);\n if (sizing) {\n return `F\\xF6r lite(t): f\\xF6rv\\xE4ntade ${issue2.origin ?? \"v\\xE4rdet\"} att ha ${adj}${issue2.minimum.toString()} ${sizing.unit}`;\n }\n return `F\\xF6r lite(t): f\\xF6rv\\xE4ntade ${issue2.origin ?? \"v\\xE4rdet\"} att ha ${adj}${issue2.minimum.toString()}`;\n }\n case \"invalid_format\": {\n const _issue = issue2;\n if (_issue.format === \"starts_with\") {\n return `Ogiltig str\\xE4ng: m\\xE5ste b\\xF6rja med \"${_issue.prefix}\"`;\n }\n if (_issue.format === \"ends_with\")\n return `Ogiltig str\\xE4ng: m\\xE5ste sluta med \"${_issue.suffix}\"`;\n if (_issue.format === \"includes\")\n return `Ogiltig str\\xE4ng: m\\xE5ste inneh\\xE5lla \"${_issue.includes}\"`;\n if (_issue.format === \"regex\")\n return `Ogiltig str\\xE4ng: m\\xE5ste matcha m\\xF6nstret \"${_issue.pattern}\"`;\n return `Ogiltig(t) ${FormatDictionary[_issue.format] ?? issue2.format}`;\n }\n case \"not_multiple_of\":\n return `Ogiltigt tal: m\\xE5ste vara en multipel av ${issue2.divisor}`;\n case \"unrecognized_keys\":\n return `${issue2.keys.length > 1 ? \"Ok\\xE4nda nycklar\" : \"Ok\\xE4nd nyckel\"}: ${joinValues(issue2.keys, \", \")}`;\n case \"invalid_key\":\n return `Ogiltig nyckel i ${issue2.origin ?? \"v\\xE4rdet\"}`;\n case \"invalid_union\":\n return \"Ogiltig input\";\n case \"invalid_element\":\n return `Ogiltigt v\\xE4rde i ${issue2.origin ?? \"v\\xE4rdet\"}`;\n default:\n return `Ogiltig input`;\n }\n };\n };\n function sv_default() {\n return {\n localeError: error37()\n };\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/ta.js\n var error38 = () => {\n const Sizable = {\n string: { unit: \"\\u0B8E\\u0BB4\\u0BC1\\u0BA4\\u0BCD\\u0BA4\\u0BC1\\u0B95\\u0BCD\\u0B95\\u0BB3\\u0BCD\", verb: \"\\u0B95\\u0BCA\\u0BA3\\u0BCD\\u0B9F\\u0BBF\\u0BB0\\u0BC1\\u0B95\\u0BCD\\u0B95 \\u0BB5\\u0BC7\\u0BA3\\u0BCD\\u0B9F\\u0BC1\\u0BAE\\u0BCD\" },\n file: { unit: \"\\u0BAA\\u0BC8\\u0B9F\\u0BCD\\u0B9F\\u0BC1\\u0B95\\u0BB3\\u0BCD\", verb: \"\\u0B95\\u0BCA\\u0BA3\\u0BCD\\u0B9F\\u0BBF\\u0BB0\\u0BC1\\u0B95\\u0BCD\\u0B95 \\u0BB5\\u0BC7\\u0BA3\\u0BCD\\u0B9F\\u0BC1\\u0BAE\\u0BCD\" },\n array: { unit: \"\\u0B89\\u0BB1\\u0BC1\\u0BAA\\u0BCD\\u0BAA\\u0BC1\\u0B95\\u0BB3\\u0BCD\", verb: \"\\u0B95\\u0BCA\\u0BA3\\u0BCD\\u0B9F\\u0BBF\\u0BB0\\u0BC1\\u0B95\\u0BCD\\u0B95 \\u0BB5\\u0BC7\\u0BA3\\u0BCD\\u0B9F\\u0BC1\\u0BAE\\u0BCD\" },\n set: { unit: \"\\u0B89\\u0BB1\\u0BC1\\u0BAA\\u0BCD\\u0BAA\\u0BC1\\u0B95\\u0BB3\\u0BCD\", verb: \"\\u0B95\\u0BCA\\u0BA3\\u0BCD\\u0B9F\\u0BBF\\u0BB0\\u0BC1\\u0B95\\u0BCD\\u0B95 \\u0BB5\\u0BC7\\u0BA3\\u0BCD\\u0B9F\\u0BC1\\u0BAE\\u0BCD\" }\n };\n function getSizing(origin) {\n return Sizable[origin] ?? null;\n }\n const FormatDictionary = {\n regex: \"\\u0B89\\u0BB3\\u0BCD\\u0BB3\\u0BC0\\u0B9F\\u0BC1\",\n email: \"\\u0BAE\\u0BBF\\u0BA9\\u0BCD\\u0BA9\\u0B9E\\u0BCD\\u0B9A\\u0BB2\\u0BCD \\u0BAE\\u0BC1\\u0B95\\u0BB5\\u0BB0\\u0BBF\",\n url: \"URL\",\n emoji: \"emoji\",\n uuid: \"UUID\",\n uuidv4: \"UUIDv4\",\n uuidv6: \"UUIDv6\",\n nanoid: \"nanoid\",\n guid: \"GUID\",\n cuid: \"cuid\",\n cuid2: \"cuid2\",\n ulid: \"ULID\",\n xid: \"XID\",\n ksuid: \"KSUID\",\n datetime: \"ISO \\u0BA4\\u0BC7\\u0BA4\\u0BBF \\u0BA8\\u0BC7\\u0BB0\\u0BAE\\u0BCD\",\n date: \"ISO \\u0BA4\\u0BC7\\u0BA4\\u0BBF\",\n time: \"ISO \\u0BA8\\u0BC7\\u0BB0\\u0BAE\\u0BCD\",\n duration: \"ISO \\u0B95\\u0BBE\\u0BB2 \\u0B85\\u0BB3\\u0BB5\\u0BC1\",\n ipv4: \"IPv4 \\u0BAE\\u0BC1\\u0B95\\u0BB5\\u0BB0\\u0BBF\",\n ipv6: \"IPv6 \\u0BAE\\u0BC1\\u0B95\\u0BB5\\u0BB0\\u0BBF\",\n cidrv4: \"IPv4 \\u0BB5\\u0BB0\\u0BAE\\u0BCD\\u0BAA\\u0BC1\",\n cidrv6: \"IPv6 \\u0BB5\\u0BB0\\u0BAE\\u0BCD\\u0BAA\\u0BC1\",\n base64: \"base64-encoded \\u0B9A\\u0BB0\\u0BAE\\u0BCD\",\n base64url: \"base64url-encoded \\u0B9A\\u0BB0\\u0BAE\\u0BCD\",\n json_string: \"JSON \\u0B9A\\u0BB0\\u0BAE\\u0BCD\",\n e164: \"E.164 \\u0B8E\\u0BA3\\u0BCD\",\n jwt: \"JWT\",\n template_literal: \"input\"\n };\n const TypeDictionary = {\n nan: \"NaN\",\n number: \"\\u0B8E\\u0BA3\\u0BCD\",\n array: \"\\u0B85\\u0BA3\\u0BBF\",\n null: \"\\u0BB5\\u0BC6\\u0BB1\\u0BC1\\u0BAE\\u0BC8\"\n };\n return (issue2) => {\n switch (issue2.code) {\n case \"invalid_type\": {\n const expected = TypeDictionary[issue2.expected] ?? issue2.expected;\n const receivedType = parsedType(issue2.input);\n const received = TypeDictionary[receivedType] ?? receivedType;\n if (/^[A-Z]/.test(issue2.expected)) {\n return `\\u0BA4\\u0BB5\\u0BB1\\u0BBE\\u0BA9 \\u0B89\\u0BB3\\u0BCD\\u0BB3\\u0BC0\\u0B9F\\u0BC1: \\u0B8E\\u0BA4\\u0BBF\\u0BB0\\u0BCD\\u0BAA\\u0BBE\\u0BB0\\u0BCD\\u0B95\\u0BCD\\u0B95\\u0BAA\\u0BCD\\u0BAA\\u0B9F\\u0BCD\\u0B9F\\u0BA4\\u0BC1 instanceof ${issue2.expected}, \\u0BAA\\u0BC6\\u0BB1\\u0BAA\\u0BCD\\u0BAA\\u0B9F\\u0BCD\\u0B9F\\u0BA4\\u0BC1 ${received}`;\n }\n return `\\u0BA4\\u0BB5\\u0BB1\\u0BBE\\u0BA9 \\u0B89\\u0BB3\\u0BCD\\u0BB3\\u0BC0\\u0B9F\\u0BC1: \\u0B8E\\u0BA4\\u0BBF\\u0BB0\\u0BCD\\u0BAA\\u0BBE\\u0BB0\\u0BCD\\u0B95\\u0BCD\\u0B95\\u0BAA\\u0BCD\\u0BAA\\u0B9F\\u0BCD\\u0B9F\\u0BA4\\u0BC1 ${expected}, \\u0BAA\\u0BC6\\u0BB1\\u0BAA\\u0BCD\\u0BAA\\u0B9F\\u0BCD\\u0B9F\\u0BA4\\u0BC1 ${received}`;\n }\n case \"invalid_value\":\n if (issue2.values.length === 1)\n return `\\u0BA4\\u0BB5\\u0BB1\\u0BBE\\u0BA9 \\u0B89\\u0BB3\\u0BCD\\u0BB3\\u0BC0\\u0B9F\\u0BC1: \\u0B8E\\u0BA4\\u0BBF\\u0BB0\\u0BCD\\u0BAA\\u0BBE\\u0BB0\\u0BCD\\u0B95\\u0BCD\\u0B95\\u0BAA\\u0BCD\\u0BAA\\u0B9F\\u0BCD\\u0B9F\\u0BA4\\u0BC1 ${stringifyPrimitive(issue2.values[0])}`;\n return `\\u0BA4\\u0BB5\\u0BB1\\u0BBE\\u0BA9 \\u0BB5\\u0BBF\\u0BB0\\u0BC1\\u0BAA\\u0BCD\\u0BAA\\u0BAE\\u0BCD: \\u0B8E\\u0BA4\\u0BBF\\u0BB0\\u0BCD\\u0BAA\\u0BBE\\u0BB0\\u0BCD\\u0B95\\u0BCD\\u0B95\\u0BAA\\u0BCD\\u0BAA\\u0B9F\\u0BCD\\u0B9F\\u0BA4\\u0BC1 ${joinValues(issue2.values, \"|\")} \\u0B87\\u0BB2\\u0BCD \\u0B92\\u0BA9\\u0BCD\\u0BB1\\u0BC1`;\n case \"too_big\": {\n const adj = issue2.inclusive ? \"<=\" : \"<\";\n const sizing = getSizing(issue2.origin);\n if (sizing) {\n return `\\u0BAE\\u0BBF\\u0B95 \\u0BAA\\u0BC6\\u0BB0\\u0BBF\\u0BAF\\u0BA4\\u0BC1: \\u0B8E\\u0BA4\\u0BBF\\u0BB0\\u0BCD\\u0BAA\\u0BBE\\u0BB0\\u0BCD\\u0B95\\u0BCD\\u0B95\\u0BAA\\u0BCD\\u0BAA\\u0B9F\\u0BCD\\u0B9F\\u0BA4\\u0BC1 ${issue2.origin ?? \"\\u0BAE\\u0BA4\\u0BBF\\u0BAA\\u0BCD\\u0BAA\\u0BC1\"} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? \"\\u0B89\\u0BB1\\u0BC1\\u0BAA\\u0BCD\\u0BAA\\u0BC1\\u0B95\\u0BB3\\u0BCD\"} \\u0B86\\u0B95 \\u0B87\\u0BB0\\u0BC1\\u0B95\\u0BCD\\u0B95 \\u0BB5\\u0BC7\\u0BA3\\u0BCD\\u0B9F\\u0BC1\\u0BAE\\u0BCD`;\n }\n return `\\u0BAE\\u0BBF\\u0B95 \\u0BAA\\u0BC6\\u0BB0\\u0BBF\\u0BAF\\u0BA4\\u0BC1: \\u0B8E\\u0BA4\\u0BBF\\u0BB0\\u0BCD\\u0BAA\\u0BBE\\u0BB0\\u0BCD\\u0B95\\u0BCD\\u0B95\\u0BAA\\u0BCD\\u0BAA\\u0B9F\\u0BCD\\u0B9F\\u0BA4\\u0BC1 ${issue2.origin ?? \"\\u0BAE\\u0BA4\\u0BBF\\u0BAA\\u0BCD\\u0BAA\\u0BC1\"} ${adj}${issue2.maximum.toString()} \\u0B86\\u0B95 \\u0B87\\u0BB0\\u0BC1\\u0B95\\u0BCD\\u0B95 \\u0BB5\\u0BC7\\u0BA3\\u0BCD\\u0B9F\\u0BC1\\u0BAE\\u0BCD`;\n }\n case \"too_small\": {\n const adj = issue2.inclusive ? \">=\" : \">\";\n const sizing = getSizing(issue2.origin);\n if (sizing) {\n return `\\u0BAE\\u0BBF\\u0B95\\u0B9A\\u0BCD \\u0B9A\\u0BBF\\u0BB1\\u0BBF\\u0BAF\\u0BA4\\u0BC1: \\u0B8E\\u0BA4\\u0BBF\\u0BB0\\u0BCD\\u0BAA\\u0BBE\\u0BB0\\u0BCD\\u0B95\\u0BCD\\u0B95\\u0BAA\\u0BCD\\u0BAA\\u0B9F\\u0BCD\\u0B9F\\u0BA4\\u0BC1 ${issue2.origin} ${adj}${issue2.minimum.toString()} ${sizing.unit} \\u0B86\\u0B95 \\u0B87\\u0BB0\\u0BC1\\u0B95\\u0BCD\\u0B95 \\u0BB5\\u0BC7\\u0BA3\\u0BCD\\u0B9F\\u0BC1\\u0BAE\\u0BCD`;\n }\n return `\\u0BAE\\u0BBF\\u0B95\\u0B9A\\u0BCD \\u0B9A\\u0BBF\\u0BB1\\u0BBF\\u0BAF\\u0BA4\\u0BC1: \\u0B8E\\u0BA4\\u0BBF\\u0BB0\\u0BCD\\u0BAA\\u0BBE\\u0BB0\\u0BCD\\u0B95\\u0BCD\\u0B95\\u0BAA\\u0BCD\\u0BAA\\u0B9F\\u0BCD\\u0B9F\\u0BA4\\u0BC1 ${issue2.origin} ${adj}${issue2.minimum.toString()} \\u0B86\\u0B95 \\u0B87\\u0BB0\\u0BC1\\u0B95\\u0BCD\\u0B95 \\u0BB5\\u0BC7\\u0BA3\\u0BCD\\u0B9F\\u0BC1\\u0BAE\\u0BCD`;\n }\n case \"invalid_format\": {\n const _issue = issue2;\n if (_issue.format === \"starts_with\")\n return `\\u0BA4\\u0BB5\\u0BB1\\u0BBE\\u0BA9 \\u0B9A\\u0BB0\\u0BAE\\u0BCD: \"${_issue.prefix}\" \\u0B87\\u0BB2\\u0BCD \\u0BA4\\u0BCA\\u0B9F\\u0B99\\u0BCD\\u0B95 \\u0BB5\\u0BC7\\u0BA3\\u0BCD\\u0B9F\\u0BC1\\u0BAE\\u0BCD`;\n if (_issue.format === \"ends_with\")\n return `\\u0BA4\\u0BB5\\u0BB1\\u0BBE\\u0BA9 \\u0B9A\\u0BB0\\u0BAE\\u0BCD: \"${_issue.suffix}\" \\u0B87\\u0BB2\\u0BCD \\u0BAE\\u0BC1\\u0B9F\\u0BBF\\u0BB5\\u0B9F\\u0BC8\\u0BAF \\u0BB5\\u0BC7\\u0BA3\\u0BCD\\u0B9F\\u0BC1\\u0BAE\\u0BCD`;\n if (_issue.format === \"includes\")\n return `\\u0BA4\\u0BB5\\u0BB1\\u0BBE\\u0BA9 \\u0B9A\\u0BB0\\u0BAE\\u0BCD: \"${_issue.includes}\" \\u0B90 \\u0B89\\u0BB3\\u0BCD\\u0BB3\\u0B9F\\u0B95\\u0BCD\\u0B95 \\u0BB5\\u0BC7\\u0BA3\\u0BCD\\u0B9F\\u0BC1\\u0BAE\\u0BCD`;\n if (_issue.format === \"regex\")\n return `\\u0BA4\\u0BB5\\u0BB1\\u0BBE\\u0BA9 \\u0B9A\\u0BB0\\u0BAE\\u0BCD: ${_issue.pattern} \\u0BAE\\u0BC1\\u0BB1\\u0BC8\\u0BAA\\u0BBE\\u0B9F\\u0BCD\\u0B9F\\u0BC1\\u0B9F\\u0BA9\\u0BCD \\u0BAA\\u0BCA\\u0BB0\\u0BC1\\u0BA8\\u0BCD\\u0BA4 \\u0BB5\\u0BC7\\u0BA3\\u0BCD\\u0B9F\\u0BC1\\u0BAE\\u0BCD`;\n return `\\u0BA4\\u0BB5\\u0BB1\\u0BBE\\u0BA9 ${FormatDictionary[_issue.format] ?? issue2.format}`;\n }\n case \"not_multiple_of\":\n return `\\u0BA4\\u0BB5\\u0BB1\\u0BBE\\u0BA9 \\u0B8E\\u0BA3\\u0BCD: ${issue2.divisor} \\u0B87\\u0BA9\\u0BCD \\u0BAA\\u0BB2\\u0BAE\\u0BBE\\u0B95 \\u0B87\\u0BB0\\u0BC1\\u0B95\\u0BCD\\u0B95 \\u0BB5\\u0BC7\\u0BA3\\u0BCD\\u0B9F\\u0BC1\\u0BAE\\u0BCD`;\n case \"unrecognized_keys\":\n return `\\u0B85\\u0B9F\\u0BC8\\u0BAF\\u0BBE\\u0BB3\\u0BAE\\u0BCD \\u0BA4\\u0BC6\\u0BB0\\u0BBF\\u0BAF\\u0BBE\\u0BA4 \\u0BB5\\u0BBF\\u0B9A\\u0BC8${issue2.keys.length > 1 ? \"\\u0B95\\u0BB3\\u0BCD\" : \"\"}: ${joinValues(issue2.keys, \", \")}`;\n case \"invalid_key\":\n return `${issue2.origin} \\u0B87\\u0BB2\\u0BCD \\u0BA4\\u0BB5\\u0BB1\\u0BBE\\u0BA9 \\u0BB5\\u0BBF\\u0B9A\\u0BC8`;\n case \"invalid_union\":\n return \"\\u0BA4\\u0BB5\\u0BB1\\u0BBE\\u0BA9 \\u0B89\\u0BB3\\u0BCD\\u0BB3\\u0BC0\\u0B9F\\u0BC1\";\n case \"invalid_element\":\n return `${issue2.origin} \\u0B87\\u0BB2\\u0BCD \\u0BA4\\u0BB5\\u0BB1\\u0BBE\\u0BA9 \\u0BAE\\u0BA4\\u0BBF\\u0BAA\\u0BCD\\u0BAA\\u0BC1`;\n default:\n return `\\u0BA4\\u0BB5\\u0BB1\\u0BBE\\u0BA9 \\u0B89\\u0BB3\\u0BCD\\u0BB3\\u0BC0\\u0B9F\\u0BC1`;\n }\n };\n };\n function ta_default() {\n return {\n localeError: error38()\n };\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/th.js\n var error39 = () => {\n const Sizable = {\n string: { unit: \"\\u0E15\\u0E31\\u0E27\\u0E2D\\u0E31\\u0E01\\u0E29\\u0E23\", verb: \"\\u0E04\\u0E27\\u0E23\\u0E21\\u0E35\" },\n file: { unit: \"\\u0E44\\u0E1A\\u0E15\\u0E4C\", verb: \"\\u0E04\\u0E27\\u0E23\\u0E21\\u0E35\" },\n array: { unit: \"\\u0E23\\u0E32\\u0E22\\u0E01\\u0E32\\u0E23\", verb: \"\\u0E04\\u0E27\\u0E23\\u0E21\\u0E35\" },\n set: { unit: \"\\u0E23\\u0E32\\u0E22\\u0E01\\u0E32\\u0E23\", verb: \"\\u0E04\\u0E27\\u0E23\\u0E21\\u0E35\" }\n };\n function getSizing(origin) {\n return Sizable[origin] ?? null;\n }\n const FormatDictionary = {\n regex: \"\\u0E02\\u0E49\\u0E2D\\u0E21\\u0E39\\u0E25\\u0E17\\u0E35\\u0E48\\u0E1B\\u0E49\\u0E2D\\u0E19\",\n email: \"\\u0E17\\u0E35\\u0E48\\u0E2D\\u0E22\\u0E39\\u0E48\\u0E2D\\u0E35\\u0E40\\u0E21\\u0E25\",\n url: \"URL\",\n emoji: \"\\u0E2D\\u0E34\\u0E42\\u0E21\\u0E08\\u0E34\",\n uuid: \"UUID\",\n uuidv4: \"UUIDv4\",\n uuidv6: \"UUIDv6\",\n nanoid: \"nanoid\",\n guid: \"GUID\",\n cuid: \"cuid\",\n cuid2: \"cuid2\",\n ulid: \"ULID\",\n xid: \"XID\",\n ksuid: \"KSUID\",\n datetime: \"\\u0E27\\u0E31\\u0E19\\u0E17\\u0E35\\u0E48\\u0E40\\u0E27\\u0E25\\u0E32\\u0E41\\u0E1A\\u0E1A ISO\",\n date: \"\\u0E27\\u0E31\\u0E19\\u0E17\\u0E35\\u0E48\\u0E41\\u0E1A\\u0E1A ISO\",\n time: \"\\u0E40\\u0E27\\u0E25\\u0E32\\u0E41\\u0E1A\\u0E1A ISO\",\n duration: \"\\u0E0A\\u0E48\\u0E27\\u0E07\\u0E40\\u0E27\\u0E25\\u0E32\\u0E41\\u0E1A\\u0E1A ISO\",\n ipv4: \"\\u0E17\\u0E35\\u0E48\\u0E2D\\u0E22\\u0E39\\u0E48 IPv4\",\n ipv6: \"\\u0E17\\u0E35\\u0E48\\u0E2D\\u0E22\\u0E39\\u0E48 IPv6\",\n cidrv4: \"\\u0E0A\\u0E48\\u0E27\\u0E07 IP \\u0E41\\u0E1A\\u0E1A IPv4\",\n cidrv6: \"\\u0E0A\\u0E48\\u0E27\\u0E07 IP \\u0E41\\u0E1A\\u0E1A IPv6\",\n base64: \"\\u0E02\\u0E49\\u0E2D\\u0E04\\u0E27\\u0E32\\u0E21\\u0E41\\u0E1A\\u0E1A Base64\",\n base64url: \"\\u0E02\\u0E49\\u0E2D\\u0E04\\u0E27\\u0E32\\u0E21\\u0E41\\u0E1A\\u0E1A Base64 \\u0E2A\\u0E33\\u0E2B\\u0E23\\u0E31\\u0E1A URL\",\n json_string: \"\\u0E02\\u0E49\\u0E2D\\u0E04\\u0E27\\u0E32\\u0E21\\u0E41\\u0E1A\\u0E1A JSON\",\n e164: \"\\u0E40\\u0E1A\\u0E2D\\u0E23\\u0E4C\\u0E42\\u0E17\\u0E23\\u0E28\\u0E31\\u0E1E\\u0E17\\u0E4C\\u0E23\\u0E30\\u0E2B\\u0E27\\u0E48\\u0E32\\u0E07\\u0E1B\\u0E23\\u0E30\\u0E40\\u0E17\\u0E28 (E.164)\",\n jwt: \"\\u0E42\\u0E17\\u0E40\\u0E04\\u0E19 JWT\",\n template_literal: \"\\u0E02\\u0E49\\u0E2D\\u0E21\\u0E39\\u0E25\\u0E17\\u0E35\\u0E48\\u0E1B\\u0E49\\u0E2D\\u0E19\"\n };\n const TypeDictionary = {\n nan: \"NaN\",\n number: \"\\u0E15\\u0E31\\u0E27\\u0E40\\u0E25\\u0E02\",\n array: \"\\u0E2D\\u0E32\\u0E23\\u0E4C\\u0E40\\u0E23\\u0E22\\u0E4C (Array)\",\n null: \"\\u0E44\\u0E21\\u0E48\\u0E21\\u0E35\\u0E04\\u0E48\\u0E32 (null)\"\n };\n return (issue2) => {\n switch (issue2.code) {\n case \"invalid_type\": {\n const expected = TypeDictionary[issue2.expected] ?? issue2.expected;\n const receivedType = parsedType(issue2.input);\n const received = TypeDictionary[receivedType] ?? receivedType;\n if (/^[A-Z]/.test(issue2.expected)) {\n return `\\u0E1B\\u0E23\\u0E30\\u0E40\\u0E20\\u0E17\\u0E02\\u0E49\\u0E2D\\u0E21\\u0E39\\u0E25\\u0E44\\u0E21\\u0E48\\u0E16\\u0E39\\u0E01\\u0E15\\u0E49\\u0E2D\\u0E07: \\u0E04\\u0E27\\u0E23\\u0E40\\u0E1B\\u0E47\\u0E19 instanceof ${issue2.expected} \\u0E41\\u0E15\\u0E48\\u0E44\\u0E14\\u0E49\\u0E23\\u0E31\\u0E1A ${received}`;\n }\n return `\\u0E1B\\u0E23\\u0E30\\u0E40\\u0E20\\u0E17\\u0E02\\u0E49\\u0E2D\\u0E21\\u0E39\\u0E25\\u0E44\\u0E21\\u0E48\\u0E16\\u0E39\\u0E01\\u0E15\\u0E49\\u0E2D\\u0E07: \\u0E04\\u0E27\\u0E23\\u0E40\\u0E1B\\u0E47\\u0E19 ${expected} \\u0E41\\u0E15\\u0E48\\u0E44\\u0E14\\u0E49\\u0E23\\u0E31\\u0E1A ${received}`;\n }\n case \"invalid_value\":\n if (issue2.values.length === 1)\n return `\\u0E04\\u0E48\\u0E32\\u0E44\\u0E21\\u0E48\\u0E16\\u0E39\\u0E01\\u0E15\\u0E49\\u0E2D\\u0E07: \\u0E04\\u0E27\\u0E23\\u0E40\\u0E1B\\u0E47\\u0E19 ${stringifyPrimitive(issue2.values[0])}`;\n return `\\u0E15\\u0E31\\u0E27\\u0E40\\u0E25\\u0E37\\u0E2D\\u0E01\\u0E44\\u0E21\\u0E48\\u0E16\\u0E39\\u0E01\\u0E15\\u0E49\\u0E2D\\u0E07: \\u0E04\\u0E27\\u0E23\\u0E40\\u0E1B\\u0E47\\u0E19\\u0E2B\\u0E19\\u0E36\\u0E48\\u0E07\\u0E43\\u0E19 ${joinValues(issue2.values, \"|\")}`;\n case \"too_big\": {\n const adj = issue2.inclusive ? \"\\u0E44\\u0E21\\u0E48\\u0E40\\u0E01\\u0E34\\u0E19\" : \"\\u0E19\\u0E49\\u0E2D\\u0E22\\u0E01\\u0E27\\u0E48\\u0E32\";\n const sizing = getSizing(issue2.origin);\n if (sizing)\n return `\\u0E40\\u0E01\\u0E34\\u0E19\\u0E01\\u0E33\\u0E2B\\u0E19\\u0E14: ${issue2.origin ?? \"\\u0E04\\u0E48\\u0E32\"} \\u0E04\\u0E27\\u0E23\\u0E21\\u0E35${adj} ${issue2.maximum.toString()} ${sizing.unit ?? \"\\u0E23\\u0E32\\u0E22\\u0E01\\u0E32\\u0E23\"}`;\n return `\\u0E40\\u0E01\\u0E34\\u0E19\\u0E01\\u0E33\\u0E2B\\u0E19\\u0E14: ${issue2.origin ?? \"\\u0E04\\u0E48\\u0E32\"} \\u0E04\\u0E27\\u0E23\\u0E21\\u0E35${adj} ${issue2.maximum.toString()}`;\n }\n case \"too_small\": {\n const adj = issue2.inclusive ? \"\\u0E2D\\u0E22\\u0E48\\u0E32\\u0E07\\u0E19\\u0E49\\u0E2D\\u0E22\" : \"\\u0E21\\u0E32\\u0E01\\u0E01\\u0E27\\u0E48\\u0E32\";\n const sizing = getSizing(issue2.origin);\n if (sizing) {\n return `\\u0E19\\u0E49\\u0E2D\\u0E22\\u0E01\\u0E27\\u0E48\\u0E32\\u0E01\\u0E33\\u0E2B\\u0E19\\u0E14: ${issue2.origin} \\u0E04\\u0E27\\u0E23\\u0E21\\u0E35${adj} ${issue2.minimum.toString()} ${sizing.unit}`;\n }\n return `\\u0E19\\u0E49\\u0E2D\\u0E22\\u0E01\\u0E27\\u0E48\\u0E32\\u0E01\\u0E33\\u0E2B\\u0E19\\u0E14: ${issue2.origin} \\u0E04\\u0E27\\u0E23\\u0E21\\u0E35${adj} ${issue2.minimum.toString()}`;\n }\n case \"invalid_format\": {\n const _issue = issue2;\n if (_issue.format === \"starts_with\") {\n return `\\u0E23\\u0E39\\u0E1B\\u0E41\\u0E1A\\u0E1A\\u0E44\\u0E21\\u0E48\\u0E16\\u0E39\\u0E01\\u0E15\\u0E49\\u0E2D\\u0E07: \\u0E02\\u0E49\\u0E2D\\u0E04\\u0E27\\u0E32\\u0E21\\u0E15\\u0E49\\u0E2D\\u0E07\\u0E02\\u0E36\\u0E49\\u0E19\\u0E15\\u0E49\\u0E19\\u0E14\\u0E49\\u0E27\\u0E22 \"${_issue.prefix}\"`;\n }\n if (_issue.format === \"ends_with\")\n return `\\u0E23\\u0E39\\u0E1B\\u0E41\\u0E1A\\u0E1A\\u0E44\\u0E21\\u0E48\\u0E16\\u0E39\\u0E01\\u0E15\\u0E49\\u0E2D\\u0E07: \\u0E02\\u0E49\\u0E2D\\u0E04\\u0E27\\u0E32\\u0E21\\u0E15\\u0E49\\u0E2D\\u0E07\\u0E25\\u0E07\\u0E17\\u0E49\\u0E32\\u0E22\\u0E14\\u0E49\\u0E27\\u0E22 \"${_issue.suffix}\"`;\n if (_issue.format === \"includes\")\n return `\\u0E23\\u0E39\\u0E1B\\u0E41\\u0E1A\\u0E1A\\u0E44\\u0E21\\u0E48\\u0E16\\u0E39\\u0E01\\u0E15\\u0E49\\u0E2D\\u0E07: \\u0E02\\u0E49\\u0E2D\\u0E04\\u0E27\\u0E32\\u0E21\\u0E15\\u0E49\\u0E2D\\u0E07\\u0E21\\u0E35 \"${_issue.includes}\" \\u0E2D\\u0E22\\u0E39\\u0E48\\u0E43\\u0E19\\u0E02\\u0E49\\u0E2D\\u0E04\\u0E27\\u0E32\\u0E21`;\n if (_issue.format === \"regex\")\n return `\\u0E23\\u0E39\\u0E1B\\u0E41\\u0E1A\\u0E1A\\u0E44\\u0E21\\u0E48\\u0E16\\u0E39\\u0E01\\u0E15\\u0E49\\u0E2D\\u0E07: \\u0E15\\u0E49\\u0E2D\\u0E07\\u0E15\\u0E23\\u0E07\\u0E01\\u0E31\\u0E1A\\u0E23\\u0E39\\u0E1B\\u0E41\\u0E1A\\u0E1A\\u0E17\\u0E35\\u0E48\\u0E01\\u0E33\\u0E2B\\u0E19\\u0E14 ${_issue.pattern}`;\n return `\\u0E23\\u0E39\\u0E1B\\u0E41\\u0E1A\\u0E1A\\u0E44\\u0E21\\u0E48\\u0E16\\u0E39\\u0E01\\u0E15\\u0E49\\u0E2D\\u0E07: ${FormatDictionary[_issue.format] ?? issue2.format}`;\n }\n case \"not_multiple_of\":\n return `\\u0E15\\u0E31\\u0E27\\u0E40\\u0E25\\u0E02\\u0E44\\u0E21\\u0E48\\u0E16\\u0E39\\u0E01\\u0E15\\u0E49\\u0E2D\\u0E07: \\u0E15\\u0E49\\u0E2D\\u0E07\\u0E40\\u0E1B\\u0E47\\u0E19\\u0E08\\u0E33\\u0E19\\u0E27\\u0E19\\u0E17\\u0E35\\u0E48\\u0E2B\\u0E32\\u0E23\\u0E14\\u0E49\\u0E27\\u0E22 ${issue2.divisor} \\u0E44\\u0E14\\u0E49\\u0E25\\u0E07\\u0E15\\u0E31\\u0E27`;\n case \"unrecognized_keys\":\n return `\\u0E1E\\u0E1A\\u0E04\\u0E35\\u0E22\\u0E4C\\u0E17\\u0E35\\u0E48\\u0E44\\u0E21\\u0E48\\u0E23\\u0E39\\u0E49\\u0E08\\u0E31\\u0E01: ${joinValues(issue2.keys, \", \")}`;\n case \"invalid_key\":\n return `\\u0E04\\u0E35\\u0E22\\u0E4C\\u0E44\\u0E21\\u0E48\\u0E16\\u0E39\\u0E01\\u0E15\\u0E49\\u0E2D\\u0E07\\u0E43\\u0E19 ${issue2.origin}`;\n case \"invalid_union\":\n return \"\\u0E02\\u0E49\\u0E2D\\u0E21\\u0E39\\u0E25\\u0E44\\u0E21\\u0E48\\u0E16\\u0E39\\u0E01\\u0E15\\u0E49\\u0E2D\\u0E07: \\u0E44\\u0E21\\u0E48\\u0E15\\u0E23\\u0E07\\u0E01\\u0E31\\u0E1A\\u0E23\\u0E39\\u0E1B\\u0E41\\u0E1A\\u0E1A\\u0E22\\u0E39\\u0E40\\u0E19\\u0E35\\u0E22\\u0E19\\u0E17\\u0E35\\u0E48\\u0E01\\u0E33\\u0E2B\\u0E19\\u0E14\\u0E44\\u0E27\\u0E49\";\n case \"invalid_element\":\n return `\\u0E02\\u0E49\\u0E2D\\u0E21\\u0E39\\u0E25\\u0E44\\u0E21\\u0E48\\u0E16\\u0E39\\u0E01\\u0E15\\u0E49\\u0E2D\\u0E07\\u0E43\\u0E19 ${issue2.origin}`;\n default:\n return `\\u0E02\\u0E49\\u0E2D\\u0E21\\u0E39\\u0E25\\u0E44\\u0E21\\u0E48\\u0E16\\u0E39\\u0E01\\u0E15\\u0E49\\u0E2D\\u0E07`;\n }\n };\n };\n function th_default() {\n return {\n localeError: error39()\n };\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/tr.js\n var error40 = () => {\n const Sizable = {\n string: { unit: \"karakter\", verb: \"olmal\\u0131\" },\n file: { unit: \"bayt\", verb: \"olmal\\u0131\" },\n array: { unit: \"\\xF6\\u011Fe\", verb: \"olmal\\u0131\" },\n set: { unit: \"\\xF6\\u011Fe\", verb: \"olmal\\u0131\" }\n };\n function getSizing(origin) {\n return Sizable[origin] ?? null;\n }\n const FormatDictionary = {\n regex: \"girdi\",\n email: \"e-posta adresi\",\n url: \"URL\",\n emoji: \"emoji\",\n uuid: \"UUID\",\n uuidv4: \"UUIDv4\",\n uuidv6: \"UUIDv6\",\n nanoid: \"nanoid\",\n guid: \"GUID\",\n cuid: \"cuid\",\n cuid2: \"cuid2\",\n ulid: \"ULID\",\n xid: \"XID\",\n ksuid: \"KSUID\",\n datetime: \"ISO tarih ve saat\",\n date: \"ISO tarih\",\n time: \"ISO saat\",\n duration: \"ISO s\\xFCre\",\n ipv4: \"IPv4 adresi\",\n ipv6: \"IPv6 adresi\",\n cidrv4: \"IPv4 aral\\u0131\\u011F\\u0131\",\n cidrv6: \"IPv6 aral\\u0131\\u011F\\u0131\",\n base64: \"base64 ile \\u015Fifrelenmi\\u015F metin\",\n base64url: \"base64url ile \\u015Fifrelenmi\\u015F metin\",\n json_string: \"JSON dizesi\",\n e164: \"E.164 say\\u0131s\\u0131\",\n jwt: \"JWT\",\n template_literal: \"\\u015Eablon dizesi\"\n };\n const TypeDictionary = {\n nan: \"NaN\"\n };\n return (issue2) => {\n switch (issue2.code) {\n case \"invalid_type\": {\n const expected = TypeDictionary[issue2.expected] ?? issue2.expected;\n const receivedType = parsedType(issue2.input);\n const received = TypeDictionary[receivedType] ?? receivedType;\n if (/^[A-Z]/.test(issue2.expected)) {\n return `Ge\\xE7ersiz de\\u011Fer: beklenen instanceof ${issue2.expected}, al\\u0131nan ${received}`;\n }\n return `Ge\\xE7ersiz de\\u011Fer: beklenen ${expected}, al\\u0131nan ${received}`;\n }\n case \"invalid_value\":\n if (issue2.values.length === 1)\n return `Ge\\xE7ersiz de\\u011Fer: beklenen ${stringifyPrimitive(issue2.values[0])}`;\n return `Ge\\xE7ersiz se\\xE7enek: a\\u015Fa\\u011F\\u0131dakilerden biri olmal\\u0131: ${joinValues(issue2.values, \"|\")}`;\n case \"too_big\": {\n const adj = issue2.inclusive ? \"<=\" : \"<\";\n const sizing = getSizing(issue2.origin);\n if (sizing)\n return `\\xC7ok b\\xFCy\\xFCk: beklenen ${issue2.origin ?? \"de\\u011Fer\"} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? \"\\xF6\\u011Fe\"}`;\n return `\\xC7ok b\\xFCy\\xFCk: beklenen ${issue2.origin ?? \"de\\u011Fer\"} ${adj}${issue2.maximum.toString()}`;\n }\n case \"too_small\": {\n const adj = issue2.inclusive ? \">=\" : \">\";\n const sizing = getSizing(issue2.origin);\n if (sizing)\n return `\\xC7ok k\\xFC\\xE7\\xFCk: beklenen ${issue2.origin} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;\n return `\\xC7ok k\\xFC\\xE7\\xFCk: beklenen ${issue2.origin} ${adj}${issue2.minimum.toString()}`;\n }\n case \"invalid_format\": {\n const _issue = issue2;\n if (_issue.format === \"starts_with\")\n return `Ge\\xE7ersiz metin: \"${_issue.prefix}\" ile ba\\u015Flamal\\u0131`;\n if (_issue.format === \"ends_with\")\n return `Ge\\xE7ersiz metin: \"${_issue.suffix}\" ile bitmeli`;\n if (_issue.format === \"includes\")\n return `Ge\\xE7ersiz metin: \"${_issue.includes}\" i\\xE7ermeli`;\n if (_issue.format === \"regex\")\n return `Ge\\xE7ersiz metin: ${_issue.pattern} desenine uymal\\u0131`;\n return `Ge\\xE7ersiz ${FormatDictionary[_issue.format] ?? issue2.format}`;\n }\n case \"not_multiple_of\":\n return `Ge\\xE7ersiz say\\u0131: ${issue2.divisor} ile tam b\\xF6l\\xFCnebilmeli`;\n case \"unrecognized_keys\":\n return `Tan\\u0131nmayan anahtar${issue2.keys.length > 1 ? \"lar\" : \"\"}: ${joinValues(issue2.keys, \", \")}`;\n case \"invalid_key\":\n return `${issue2.origin} i\\xE7inde ge\\xE7ersiz anahtar`;\n case \"invalid_union\":\n return \"Ge\\xE7ersiz de\\u011Fer\";\n case \"invalid_element\":\n return `${issue2.origin} i\\xE7inde ge\\xE7ersiz de\\u011Fer`;\n default:\n return `Ge\\xE7ersiz de\\u011Fer`;\n }\n };\n };\n function tr_default() {\n return {\n localeError: error40()\n };\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/uk.js\n var error41 = () => {\n const Sizable = {\n string: { unit: \"\\u0441\\u0438\\u043C\\u0432\\u043E\\u043B\\u0456\\u0432\", verb: \"\\u043C\\u0430\\u0442\\u0438\\u043C\\u0435\" },\n file: { unit: \"\\u0431\\u0430\\u0439\\u0442\\u0456\\u0432\", verb: \"\\u043C\\u0430\\u0442\\u0438\\u043C\\u0435\" },\n array: { unit: \"\\u0435\\u043B\\u0435\\u043C\\u0435\\u043D\\u0442\\u0456\\u0432\", verb: \"\\u043C\\u0430\\u0442\\u0438\\u043C\\u0435\" },\n set: { unit: \"\\u0435\\u043B\\u0435\\u043C\\u0435\\u043D\\u0442\\u0456\\u0432\", verb: \"\\u043C\\u0430\\u0442\\u0438\\u043C\\u0435\" }\n };\n function getSizing(origin) {\n return Sizable[origin] ?? null;\n }\n const FormatDictionary = {\n regex: \"\\u0432\\u0445\\u0456\\u0434\\u043D\\u0456 \\u0434\\u0430\\u043D\\u0456\",\n email: \"\\u0430\\u0434\\u0440\\u0435\\u0441\\u0430 \\u0435\\u043B\\u0435\\u043A\\u0442\\u0440\\u043E\\u043D\\u043D\\u043E\\u0457 \\u043F\\u043E\\u0448\\u0442\\u0438\",\n url: \"URL\",\n emoji: \"\\u0435\\u043C\\u043E\\u0434\\u0437\\u0456\",\n uuid: \"UUID\",\n uuidv4: \"UUIDv4\",\n uuidv6: \"UUIDv6\",\n nanoid: \"nanoid\",\n guid: \"GUID\",\n cuid: \"cuid\",\n cuid2: \"cuid2\",\n ulid: \"ULID\",\n xid: \"XID\",\n ksuid: \"KSUID\",\n datetime: \"\\u0434\\u0430\\u0442\\u0430 \\u0442\\u0430 \\u0447\\u0430\\u0441 ISO\",\n date: \"\\u0434\\u0430\\u0442\\u0430 ISO\",\n time: \"\\u0447\\u0430\\u0441 ISO\",\n duration: \"\\u0442\\u0440\\u0438\\u0432\\u0430\\u043B\\u0456\\u0441\\u0442\\u044C ISO\",\n ipv4: \"\\u0430\\u0434\\u0440\\u0435\\u0441\\u0430 IPv4\",\n ipv6: \"\\u0430\\u0434\\u0440\\u0435\\u0441\\u0430 IPv6\",\n cidrv4: \"\\u0434\\u0456\\u0430\\u043F\\u0430\\u0437\\u043E\\u043D IPv4\",\n cidrv6: \"\\u0434\\u0456\\u0430\\u043F\\u0430\\u0437\\u043E\\u043D IPv6\",\n base64: \"\\u0440\\u044F\\u0434\\u043E\\u043A \\u0443 \\u043A\\u043E\\u0434\\u0443\\u0432\\u0430\\u043D\\u043D\\u0456 base64\",\n base64url: \"\\u0440\\u044F\\u0434\\u043E\\u043A \\u0443 \\u043A\\u043E\\u0434\\u0443\\u0432\\u0430\\u043D\\u043D\\u0456 base64url\",\n json_string: \"\\u0440\\u044F\\u0434\\u043E\\u043A JSON\",\n e164: \"\\u043D\\u043E\\u043C\\u0435\\u0440 E.164\",\n jwt: \"JWT\",\n template_literal: \"\\u0432\\u0445\\u0456\\u0434\\u043D\\u0456 \\u0434\\u0430\\u043D\\u0456\"\n };\n const TypeDictionary = {\n nan: \"NaN\",\n number: \"\\u0447\\u0438\\u0441\\u043B\\u043E\",\n array: \"\\u043C\\u0430\\u0441\\u0438\\u0432\"\n };\n return (issue2) => {\n switch (issue2.code) {\n case \"invalid_type\": {\n const expected = TypeDictionary[issue2.expected] ?? issue2.expected;\n const receivedType = parsedType(issue2.input);\n const received = TypeDictionary[receivedType] ?? receivedType;\n if (/^[A-Z]/.test(issue2.expected)) {\n return `\\u041D\\u0435\\u043F\\u0440\\u0430\\u0432\\u0438\\u043B\\u044C\\u043D\\u0456 \\u0432\\u0445\\u0456\\u0434\\u043D\\u0456 \\u0434\\u0430\\u043D\\u0456: \\u043E\\u0447\\u0456\\u043A\\u0443\\u0454\\u0442\\u044C\\u0441\\u044F instanceof ${issue2.expected}, \\u043E\\u0442\\u0440\\u0438\\u043C\\u0430\\u043D\\u043E ${received}`;\n }\n return `\\u041D\\u0435\\u043F\\u0440\\u0430\\u0432\\u0438\\u043B\\u044C\\u043D\\u0456 \\u0432\\u0445\\u0456\\u0434\\u043D\\u0456 \\u0434\\u0430\\u043D\\u0456: \\u043E\\u0447\\u0456\\u043A\\u0443\\u0454\\u0442\\u044C\\u0441\\u044F ${expected}, \\u043E\\u0442\\u0440\\u0438\\u043C\\u0430\\u043D\\u043E ${received}`;\n }\n case \"invalid_value\":\n if (issue2.values.length === 1)\n return `\\u041D\\u0435\\u043F\\u0440\\u0430\\u0432\\u0438\\u043B\\u044C\\u043D\\u0456 \\u0432\\u0445\\u0456\\u0434\\u043D\\u0456 \\u0434\\u0430\\u043D\\u0456: \\u043E\\u0447\\u0456\\u043A\\u0443\\u0454\\u0442\\u044C\\u0441\\u044F ${stringifyPrimitive(issue2.values[0])}`;\n return `\\u041D\\u0435\\u043F\\u0440\\u0430\\u0432\\u0438\\u043B\\u044C\\u043D\\u0430 \\u043E\\u043F\\u0446\\u0456\\u044F: \\u043E\\u0447\\u0456\\u043A\\u0443\\u0454\\u0442\\u044C\\u0441\\u044F \\u043E\\u0434\\u043D\\u0435 \\u0437 ${joinValues(issue2.values, \"|\")}`;\n case \"too_big\": {\n const adj = issue2.inclusive ? \"<=\" : \"<\";\n const sizing = getSizing(issue2.origin);\n if (sizing)\n return `\\u0417\\u0430\\u043D\\u0430\\u0434\\u0442\\u043E \\u0432\\u0435\\u043B\\u0438\\u043A\\u0435: \\u043E\\u0447\\u0456\\u043A\\u0443\\u0454\\u0442\\u044C\\u0441\\u044F, \\u0449\\u043E ${issue2.origin ?? \"\\u0437\\u043D\\u0430\\u0447\\u0435\\u043D\\u043D\\u044F\"} ${sizing.verb} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? \"\\u0435\\u043B\\u0435\\u043C\\u0435\\u043D\\u0442\\u0456\\u0432\"}`;\n return `\\u0417\\u0430\\u043D\\u0430\\u0434\\u0442\\u043E \\u0432\\u0435\\u043B\\u0438\\u043A\\u0435: \\u043E\\u0447\\u0456\\u043A\\u0443\\u0454\\u0442\\u044C\\u0441\\u044F, \\u0449\\u043E ${issue2.origin ?? \"\\u0437\\u043D\\u0430\\u0447\\u0435\\u043D\\u043D\\u044F\"} \\u0431\\u0443\\u0434\\u0435 ${adj}${issue2.maximum.toString()}`;\n }\n case \"too_small\": {\n const adj = issue2.inclusive ? \">=\" : \">\";\n const sizing = getSizing(issue2.origin);\n if (sizing) {\n return `\\u0417\\u0430\\u043D\\u0430\\u0434\\u0442\\u043E \\u043C\\u0430\\u043B\\u0435: \\u043E\\u0447\\u0456\\u043A\\u0443\\u0454\\u0442\\u044C\\u0441\\u044F, \\u0449\\u043E ${issue2.origin} ${sizing.verb} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;\n }\n return `\\u0417\\u0430\\u043D\\u0430\\u0434\\u0442\\u043E \\u043C\\u0430\\u043B\\u0435: \\u043E\\u0447\\u0456\\u043A\\u0443\\u0454\\u0442\\u044C\\u0441\\u044F, \\u0449\\u043E ${issue2.origin} \\u0431\\u0443\\u0434\\u0435 ${adj}${issue2.minimum.toString()}`;\n }\n case \"invalid_format\": {\n const _issue = issue2;\n if (_issue.format === \"starts_with\")\n return `\\u041D\\u0435\\u043F\\u0440\\u0430\\u0432\\u0438\\u043B\\u044C\\u043D\\u0438\\u0439 \\u0440\\u044F\\u0434\\u043E\\u043A: \\u043F\\u043E\\u0432\\u0438\\u043D\\u0435\\u043D \\u043F\\u043E\\u0447\\u0438\\u043D\\u0430\\u0442\\u0438\\u0441\\u044F \\u0437 \"${_issue.prefix}\"`;\n if (_issue.format === \"ends_with\")\n return `\\u041D\\u0435\\u043F\\u0440\\u0430\\u0432\\u0438\\u043B\\u044C\\u043D\\u0438\\u0439 \\u0440\\u044F\\u0434\\u043E\\u043A: \\u043F\\u043E\\u0432\\u0438\\u043D\\u0435\\u043D \\u0437\\u0430\\u043A\\u0456\\u043D\\u0447\\u0443\\u0432\\u0430\\u0442\\u0438\\u0441\\u044F \\u043D\\u0430 \"${_issue.suffix}\"`;\n if (_issue.format === \"includes\")\n return `\\u041D\\u0435\\u043F\\u0440\\u0430\\u0432\\u0438\\u043B\\u044C\\u043D\\u0438\\u0439 \\u0440\\u044F\\u0434\\u043E\\u043A: \\u043F\\u043E\\u0432\\u0438\\u043D\\u0435\\u043D \\u043C\\u0456\\u0441\\u0442\\u0438\\u0442\\u0438 \"${_issue.includes}\"`;\n if (_issue.format === \"regex\")\n return `\\u041D\\u0435\\u043F\\u0440\\u0430\\u0432\\u0438\\u043B\\u044C\\u043D\\u0438\\u0439 \\u0440\\u044F\\u0434\\u043E\\u043A: \\u043F\\u043E\\u0432\\u0438\\u043D\\u0435\\u043D \\u0432\\u0456\\u0434\\u043F\\u043E\\u0432\\u0456\\u0434\\u0430\\u0442\\u0438 \\u0448\\u0430\\u0431\\u043B\\u043E\\u043D\\u0443 ${_issue.pattern}`;\n return `\\u041D\\u0435\\u043F\\u0440\\u0430\\u0432\\u0438\\u043B\\u044C\\u043D\\u0438\\u0439 ${FormatDictionary[_issue.format] ?? issue2.format}`;\n }\n case \"not_multiple_of\":\n return `\\u041D\\u0435\\u043F\\u0440\\u0430\\u0432\\u0438\\u043B\\u044C\\u043D\\u0435 \\u0447\\u0438\\u0441\\u043B\\u043E: \\u043F\\u043E\\u0432\\u0438\\u043D\\u043D\\u043E \\u0431\\u0443\\u0442\\u0438 \\u043A\\u0440\\u0430\\u0442\\u043D\\u0438\\u043C ${issue2.divisor}`;\n case \"unrecognized_keys\":\n return `\\u041D\\u0435\\u0440\\u043E\\u0437\\u043F\\u0456\\u0437\\u043D\\u0430\\u043D\\u0438\\u0439 \\u043A\\u043B\\u044E\\u0447${issue2.keys.length > 1 ? \"\\u0456\" : \"\"}: ${joinValues(issue2.keys, \", \")}`;\n case \"invalid_key\":\n return `\\u041D\\u0435\\u043F\\u0440\\u0430\\u0432\\u0438\\u043B\\u044C\\u043D\\u0438\\u0439 \\u043A\\u043B\\u044E\\u0447 \\u0443 ${issue2.origin}`;\n case \"invalid_union\":\n return \"\\u041D\\u0435\\u043F\\u0440\\u0430\\u0432\\u0438\\u043B\\u044C\\u043D\\u0456 \\u0432\\u0445\\u0456\\u0434\\u043D\\u0456 \\u0434\\u0430\\u043D\\u0456\";\n case \"invalid_element\":\n return `\\u041D\\u0435\\u043F\\u0440\\u0430\\u0432\\u0438\\u043B\\u044C\\u043D\\u0435 \\u0437\\u043D\\u0430\\u0447\\u0435\\u043D\\u043D\\u044F \\u0443 ${issue2.origin}`;\n default:\n return `\\u041D\\u0435\\u043F\\u0440\\u0430\\u0432\\u0438\\u043B\\u044C\\u043D\\u0456 \\u0432\\u0445\\u0456\\u0434\\u043D\\u0456 \\u0434\\u0430\\u043D\\u0456`;\n }\n };\n };\n function uk_default() {\n return {\n localeError: error41()\n };\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/ua.js\n function ua_default() {\n return uk_default();\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/ur.js\n var error42 = () => {\n const Sizable = {\n string: { unit: \"\\u062D\\u0631\\u0648\\u0641\", verb: \"\\u06C1\\u0648\\u0646\\u0627\" },\n file: { unit: \"\\u0628\\u0627\\u0626\\u0679\\u0633\", verb: \"\\u06C1\\u0648\\u0646\\u0627\" },\n array: { unit: \"\\u0622\\u0626\\u0679\\u0645\\u0632\", verb: \"\\u06C1\\u0648\\u0646\\u0627\" },\n set: { unit: \"\\u0622\\u0626\\u0679\\u0645\\u0632\", verb: \"\\u06C1\\u0648\\u0646\\u0627\" }\n };\n function getSizing(origin) {\n return Sizable[origin] ?? null;\n }\n const FormatDictionary = {\n regex: \"\\u0627\\u0646 \\u067E\\u0679\",\n email: \"\\u0627\\u06CC \\u0645\\u06CC\\u0644 \\u0627\\u06CC\\u0688\\u0631\\u06CC\\u0633\",\n url: \"\\u06CC\\u0648 \\u0622\\u0631 \\u0627\\u06CC\\u0644\",\n emoji: \"\\u0627\\u06CC\\u0645\\u0648\\u062C\\u06CC\",\n uuid: \"\\u06CC\\u0648 \\u06CC\\u0648 \\u0622\\u0626\\u06CC \\u0688\\u06CC\",\n uuidv4: \"\\u06CC\\u0648 \\u06CC\\u0648 \\u0622\\u0626\\u06CC \\u0688\\u06CC \\u0648\\u06CC 4\",\n uuidv6: \"\\u06CC\\u0648 \\u06CC\\u0648 \\u0622\\u0626\\u06CC \\u0688\\u06CC \\u0648\\u06CC 6\",\n nanoid: \"\\u0646\\u06CC\\u0646\\u0648 \\u0622\\u0626\\u06CC \\u0688\\u06CC\",\n guid: \"\\u062C\\u06CC \\u06CC\\u0648 \\u0622\\u0626\\u06CC \\u0688\\u06CC\",\n cuid: \"\\u0633\\u06CC \\u06CC\\u0648 \\u0622\\u0626\\u06CC \\u0688\\u06CC\",\n cuid2: \"\\u0633\\u06CC \\u06CC\\u0648 \\u0622\\u0626\\u06CC \\u0688\\u06CC 2\",\n ulid: \"\\u06CC\\u0648 \\u0627\\u06CC\\u0644 \\u0622\\u0626\\u06CC \\u0688\\u06CC\",\n xid: \"\\u0627\\u06CC\\u06A9\\u0633 \\u0622\\u0626\\u06CC \\u0688\\u06CC\",\n ksuid: \"\\u06A9\\u06D2 \\u0627\\u06CC\\u0633 \\u06CC\\u0648 \\u0622\\u0626\\u06CC \\u0688\\u06CC\",\n datetime: \"\\u0622\\u0626\\u06CC \\u0627\\u06CC\\u0633 \\u0627\\u0648 \\u0688\\u06CC\\u0679 \\u0679\\u0627\\u0626\\u0645\",\n date: \"\\u0622\\u0626\\u06CC \\u0627\\u06CC\\u0633 \\u0627\\u0648 \\u062A\\u0627\\u0631\\u06CC\\u062E\",\n time: \"\\u0622\\u0626\\u06CC \\u0627\\u06CC\\u0633 \\u0627\\u0648 \\u0648\\u0642\\u062A\",\n duration: \"\\u0622\\u0626\\u06CC \\u0627\\u06CC\\u0633 \\u0627\\u0648 \\u0645\\u062F\\u062A\",\n ipv4: \"\\u0622\\u0626\\u06CC \\u067E\\u06CC \\u0648\\u06CC 4 \\u0627\\u06CC\\u0688\\u0631\\u06CC\\u0633\",\n ipv6: \"\\u0622\\u0626\\u06CC \\u067E\\u06CC \\u0648\\u06CC 6 \\u0627\\u06CC\\u0688\\u0631\\u06CC\\u0633\",\n cidrv4: \"\\u0622\\u0626\\u06CC \\u067E\\u06CC \\u0648\\u06CC 4 \\u0631\\u06CC\\u0646\\u062C\",\n cidrv6: \"\\u0622\\u0626\\u06CC \\u067E\\u06CC \\u0648\\u06CC 6 \\u0631\\u06CC\\u0646\\u062C\",\n base64: \"\\u0628\\u06CC\\u0633 64 \\u0627\\u0646 \\u06A9\\u0648\\u0688\\u0688 \\u0633\\u0679\\u0631\\u0646\\u06AF\",\n base64url: \"\\u0628\\u06CC\\u0633 64 \\u06CC\\u0648 \\u0622\\u0631 \\u0627\\u06CC\\u0644 \\u0627\\u0646 \\u06A9\\u0648\\u0688\\u0688 \\u0633\\u0679\\u0631\\u0646\\u06AF\",\n json_string: \"\\u062C\\u06D2 \\u0627\\u06CC\\u0633 \\u0627\\u0648 \\u0627\\u06CC\\u0646 \\u0633\\u0679\\u0631\\u0646\\u06AF\",\n e164: \"\\u0627\\u06CC 164 \\u0646\\u0645\\u0628\\u0631\",\n jwt: \"\\u062C\\u06D2 \\u0688\\u0628\\u0644\\u06CC\\u0648 \\u0679\\u06CC\",\n template_literal: \"\\u0627\\u0646 \\u067E\\u0679\"\n };\n const TypeDictionary = {\n nan: \"NaN\",\n number: \"\\u0646\\u0645\\u0628\\u0631\",\n array: \"\\u0622\\u0631\\u06D2\",\n null: \"\\u0646\\u0644\"\n };\n return (issue2) => {\n switch (issue2.code) {\n case \"invalid_type\": {\n const expected = TypeDictionary[issue2.expected] ?? issue2.expected;\n const receivedType = parsedType(issue2.input);\n const received = TypeDictionary[receivedType] ?? receivedType;\n if (/^[A-Z]/.test(issue2.expected)) {\n return `\\u063A\\u0644\\u0637 \\u0627\\u0646 \\u067E\\u0679: instanceof ${issue2.expected} \\u0645\\u062A\\u0648\\u0642\\u0639 \\u062A\\u06BE\\u0627\\u060C ${received} \\u0645\\u0648\\u0635\\u0648\\u0644 \\u06C1\\u0648\\u0627`;\n }\n return `\\u063A\\u0644\\u0637 \\u0627\\u0646 \\u067E\\u0679: ${expected} \\u0645\\u062A\\u0648\\u0642\\u0639 \\u062A\\u06BE\\u0627\\u060C ${received} \\u0645\\u0648\\u0635\\u0648\\u0644 \\u06C1\\u0648\\u0627`;\n }\n case \"invalid_value\":\n if (issue2.values.length === 1)\n return `\\u063A\\u0644\\u0637 \\u0627\\u0646 \\u067E\\u0679: ${stringifyPrimitive(issue2.values[0])} \\u0645\\u062A\\u0648\\u0642\\u0639 \\u062A\\u06BE\\u0627`;\n return `\\u063A\\u0644\\u0637 \\u0622\\u067E\\u0634\\u0646: ${joinValues(issue2.values, \"|\")} \\u0645\\u06CC\\u06BA \\u0633\\u06D2 \\u0627\\u06CC\\u06A9 \\u0645\\u062A\\u0648\\u0642\\u0639 \\u062A\\u06BE\\u0627`;\n case \"too_big\": {\n const adj = issue2.inclusive ? \"<=\" : \"<\";\n const sizing = getSizing(issue2.origin);\n if (sizing)\n return `\\u0628\\u06C1\\u062A \\u0628\\u0691\\u0627: ${issue2.origin ?? \"\\u0648\\u06CC\\u0644\\u06CC\\u0648\"} \\u06A9\\u06D2 ${adj}${issue2.maximum.toString()} ${sizing.unit ?? \"\\u0639\\u0646\\u0627\\u0635\\u0631\"} \\u06C1\\u0648\\u0646\\u06D2 \\u0645\\u062A\\u0648\\u0642\\u0639 \\u062A\\u06BE\\u06D2`;\n return `\\u0628\\u06C1\\u062A \\u0628\\u0691\\u0627: ${issue2.origin ?? \"\\u0648\\u06CC\\u0644\\u06CC\\u0648\"} \\u06A9\\u0627 ${adj}${issue2.maximum.toString()} \\u06C1\\u0648\\u0646\\u0627 \\u0645\\u062A\\u0648\\u0642\\u0639 \\u062A\\u06BE\\u0627`;\n }\n case \"too_small\": {\n const adj = issue2.inclusive ? \">=\" : \">\";\n const sizing = getSizing(issue2.origin);\n if (sizing) {\n return `\\u0628\\u06C1\\u062A \\u0686\\u06BE\\u0648\\u0679\\u0627: ${issue2.origin} \\u06A9\\u06D2 ${adj}${issue2.minimum.toString()} ${sizing.unit} \\u06C1\\u0648\\u0646\\u06D2 \\u0645\\u062A\\u0648\\u0642\\u0639 \\u062A\\u06BE\\u06D2`;\n }\n return `\\u0628\\u06C1\\u062A \\u0686\\u06BE\\u0648\\u0679\\u0627: ${issue2.origin} \\u06A9\\u0627 ${adj}${issue2.minimum.toString()} \\u06C1\\u0648\\u0646\\u0627 \\u0645\\u062A\\u0648\\u0642\\u0639 \\u062A\\u06BE\\u0627`;\n }\n case \"invalid_format\": {\n const _issue = issue2;\n if (_issue.format === \"starts_with\") {\n return `\\u063A\\u0644\\u0637 \\u0633\\u0679\\u0631\\u0646\\u06AF: \"${_issue.prefix}\" \\u0633\\u06D2 \\u0634\\u0631\\u0648\\u0639 \\u06C1\\u0648\\u0646\\u0627 \\u0686\\u0627\\u06C1\\u06CC\\u06D2`;\n }\n if (_issue.format === \"ends_with\")\n return `\\u063A\\u0644\\u0637 \\u0633\\u0679\\u0631\\u0646\\u06AF: \"${_issue.suffix}\" \\u067E\\u0631 \\u062E\\u062A\\u0645 \\u06C1\\u0648\\u0646\\u0627 \\u0686\\u0627\\u06C1\\u06CC\\u06D2`;\n if (_issue.format === \"includes\")\n return `\\u063A\\u0644\\u0637 \\u0633\\u0679\\u0631\\u0646\\u06AF: \"${_issue.includes}\" \\u0634\\u0627\\u0645\\u0644 \\u06C1\\u0648\\u0646\\u0627 \\u0686\\u0627\\u06C1\\u06CC\\u06D2`;\n if (_issue.format === \"regex\")\n return `\\u063A\\u0644\\u0637 \\u0633\\u0679\\u0631\\u0646\\u06AF: \\u067E\\u06CC\\u0679\\u0631\\u0646 ${_issue.pattern} \\u0633\\u06D2 \\u0645\\u06CC\\u0686 \\u06C1\\u0648\\u0646\\u0627 \\u0686\\u0627\\u06C1\\u06CC\\u06D2`;\n return `\\u063A\\u0644\\u0637 ${FormatDictionary[_issue.format] ?? issue2.format}`;\n }\n case \"not_multiple_of\":\n return `\\u063A\\u0644\\u0637 \\u0646\\u0645\\u0628\\u0631: ${issue2.divisor} \\u06A9\\u0627 \\u0645\\u0636\\u0627\\u0639\\u0641 \\u06C1\\u0648\\u0646\\u0627 \\u0686\\u0627\\u06C1\\u06CC\\u06D2`;\n case \"unrecognized_keys\":\n return `\\u063A\\u06CC\\u0631 \\u062A\\u0633\\u0644\\u06CC\\u0645 \\u0634\\u062F\\u06C1 \\u06A9\\u06CC${issue2.keys.length > 1 ? \"\\u0632\" : \"\"}: ${joinValues(issue2.keys, \"\\u060C \")}`;\n case \"invalid_key\":\n return `${issue2.origin} \\u0645\\u06CC\\u06BA \\u063A\\u0644\\u0637 \\u06A9\\u06CC`;\n case \"invalid_union\":\n return \"\\u063A\\u0644\\u0637 \\u0627\\u0646 \\u067E\\u0679\";\n case \"invalid_element\":\n return `${issue2.origin} \\u0645\\u06CC\\u06BA \\u063A\\u0644\\u0637 \\u0648\\u06CC\\u0644\\u06CC\\u0648`;\n default:\n return `\\u063A\\u0644\\u0637 \\u0627\\u0646 \\u067E\\u0679`;\n }\n };\n };\n function ur_default() {\n return {\n localeError: error42()\n };\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/uz.js\n var error43 = () => {\n const Sizable = {\n string: { unit: \"belgi\", verb: \"bo\\u2018lishi kerak\" },\n file: { unit: \"bayt\", verb: \"bo\\u2018lishi kerak\" },\n array: { unit: \"element\", verb: \"bo\\u2018lishi kerak\" },\n set: { unit: \"element\", verb: \"bo\\u2018lishi kerak\" }\n };\n function getSizing(origin) {\n return Sizable[origin] ?? null;\n }\n const FormatDictionary = {\n regex: \"kirish\",\n email: \"elektron pochta manzili\",\n url: \"URL\",\n emoji: \"emoji\",\n uuid: \"UUID\",\n uuidv4: \"UUIDv4\",\n uuidv6: \"UUIDv6\",\n nanoid: \"nanoid\",\n guid: \"GUID\",\n cuid: \"cuid\",\n cuid2: \"cuid2\",\n ulid: \"ULID\",\n xid: \"XID\",\n ksuid: \"KSUID\",\n datetime: \"ISO sana va vaqti\",\n date: \"ISO sana\",\n time: \"ISO vaqt\",\n duration: \"ISO davomiylik\",\n ipv4: \"IPv4 manzil\",\n ipv6: \"IPv6 manzil\",\n mac: \"MAC manzil\",\n cidrv4: \"IPv4 diapazon\",\n cidrv6: \"IPv6 diapazon\",\n base64: \"base64 kodlangan satr\",\n base64url: \"base64url kodlangan satr\",\n json_string: \"JSON satr\",\n e164: \"E.164 raqam\",\n jwt: \"JWT\",\n template_literal: \"kirish\"\n };\n const TypeDictionary = {\n nan: \"NaN\",\n number: \"raqam\",\n array: \"massiv\"\n };\n return (issue2) => {\n switch (issue2.code) {\n case \"invalid_type\": {\n const expected = TypeDictionary[issue2.expected] ?? issue2.expected;\n const receivedType = parsedType(issue2.input);\n const received = TypeDictionary[receivedType] ?? receivedType;\n if (/^[A-Z]/.test(issue2.expected)) {\n return `Noto\\u2018g\\u2018ri kirish: kutilgan instanceof ${issue2.expected}, qabul qilingan ${received}`;\n }\n return `Noto\\u2018g\\u2018ri kirish: kutilgan ${expected}, qabul qilingan ${received}`;\n }\n case \"invalid_value\":\n if (issue2.values.length === 1)\n return `Noto\\u2018g\\u2018ri kirish: kutilgan ${stringifyPrimitive(issue2.values[0])}`;\n return `Noto\\u2018g\\u2018ri variant: quyidagilardan biri kutilgan ${joinValues(issue2.values, \"|\")}`;\n case \"too_big\": {\n const adj = issue2.inclusive ? \"<=\" : \"<\";\n const sizing = getSizing(issue2.origin);\n if (sizing)\n return `Juda katta: kutilgan ${issue2.origin ?? \"qiymat\"} ${adj}${issue2.maximum.toString()} ${sizing.unit} ${sizing.verb}`;\n return `Juda katta: kutilgan ${issue2.origin ?? \"qiymat\"} ${adj}${issue2.maximum.toString()}`;\n }\n case \"too_small\": {\n const adj = issue2.inclusive ? \">=\" : \">\";\n const sizing = getSizing(issue2.origin);\n if (sizing) {\n return `Juda kichik: kutilgan ${issue2.origin} ${adj}${issue2.minimum.toString()} ${sizing.unit} ${sizing.verb}`;\n }\n return `Juda kichik: kutilgan ${issue2.origin} ${adj}${issue2.minimum.toString()}`;\n }\n case \"invalid_format\": {\n const _issue = issue2;\n if (_issue.format === \"starts_with\")\n return `Noto\\u2018g\\u2018ri satr: \"${_issue.prefix}\" bilan boshlanishi kerak`;\n if (_issue.format === \"ends_with\")\n return `Noto\\u2018g\\u2018ri satr: \"${_issue.suffix}\" bilan tugashi kerak`;\n if (_issue.format === \"includes\")\n return `Noto\\u2018g\\u2018ri satr: \"${_issue.includes}\" ni o\\u2018z ichiga olishi kerak`;\n if (_issue.format === \"regex\")\n return `Noto\\u2018g\\u2018ri satr: ${_issue.pattern} shabloniga mos kelishi kerak`;\n return `Noto\\u2018g\\u2018ri ${FormatDictionary[_issue.format] ?? issue2.format}`;\n }\n case \"not_multiple_of\":\n return `Noto\\u2018g\\u2018ri raqam: ${issue2.divisor} ning karralisi bo\\u2018lishi kerak`;\n case \"unrecognized_keys\":\n return `Noma\\u2019lum kalit${issue2.keys.length > 1 ? \"lar\" : \"\"}: ${joinValues(issue2.keys, \", \")}`;\n case \"invalid_key\":\n return `${issue2.origin} dagi kalit noto\\u2018g\\u2018ri`;\n case \"invalid_union\":\n return \"Noto\\u2018g\\u2018ri kirish\";\n case \"invalid_element\":\n return `${issue2.origin} da noto\\u2018g\\u2018ri qiymat`;\n default:\n return `Noto\\u2018g\\u2018ri kirish`;\n }\n };\n };\n function uz_default() {\n return {\n localeError: error43()\n };\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/vi.js\n var error44 = () => {\n const Sizable = {\n string: { unit: \"k\\xFD t\\u1EF1\", verb: \"c\\xF3\" },\n file: { unit: \"byte\", verb: \"c\\xF3\" },\n array: { unit: \"ph\\u1EA7n t\\u1EED\", verb: \"c\\xF3\" },\n set: { unit: \"ph\\u1EA7n t\\u1EED\", verb: \"c\\xF3\" }\n };\n function getSizing(origin) {\n return Sizable[origin] ?? null;\n }\n const FormatDictionary = {\n regex: \"\\u0111\\u1EA7u v\\xE0o\",\n email: \"\\u0111\\u1ECBa ch\\u1EC9 email\",\n url: \"URL\",\n emoji: \"emoji\",\n uuid: \"UUID\",\n uuidv4: \"UUIDv4\",\n uuidv6: \"UUIDv6\",\n nanoid: \"nanoid\",\n guid: \"GUID\",\n cuid: \"cuid\",\n cuid2: \"cuid2\",\n ulid: \"ULID\",\n xid: \"XID\",\n ksuid: \"KSUID\",\n datetime: \"ng\\xE0y gi\\u1EDD ISO\",\n date: \"ng\\xE0y ISO\",\n time: \"gi\\u1EDD ISO\",\n duration: \"kho\\u1EA3ng th\\u1EDDi gian ISO\",\n ipv4: \"\\u0111\\u1ECBa ch\\u1EC9 IPv4\",\n ipv6: \"\\u0111\\u1ECBa ch\\u1EC9 IPv6\",\n cidrv4: \"d\\u1EA3i IPv4\",\n cidrv6: \"d\\u1EA3i IPv6\",\n base64: \"chu\\u1ED7i m\\xE3 h\\xF3a base64\",\n base64url: \"chu\\u1ED7i m\\xE3 h\\xF3a base64url\",\n json_string: \"chu\\u1ED7i JSON\",\n e164: \"s\\u1ED1 E.164\",\n jwt: \"JWT\",\n template_literal: \"\\u0111\\u1EA7u v\\xE0o\"\n };\n const TypeDictionary = {\n nan: \"NaN\",\n number: \"s\\u1ED1\",\n array: \"m\\u1EA3ng\"\n };\n return (issue2) => {\n switch (issue2.code) {\n case \"invalid_type\": {\n const expected = TypeDictionary[issue2.expected] ?? issue2.expected;\n const receivedType = parsedType(issue2.input);\n const received = TypeDictionary[receivedType] ?? receivedType;\n if (/^[A-Z]/.test(issue2.expected)) {\n return `\\u0110\\u1EA7u v\\xE0o kh\\xF4ng h\\u1EE3p l\\u1EC7: mong \\u0111\\u1EE3i instanceof ${issue2.expected}, nh\\u1EADn \\u0111\\u01B0\\u1EE3c ${received}`;\n }\n return `\\u0110\\u1EA7u v\\xE0o kh\\xF4ng h\\u1EE3p l\\u1EC7: mong \\u0111\\u1EE3i ${expected}, nh\\u1EADn \\u0111\\u01B0\\u1EE3c ${received}`;\n }\n case \"invalid_value\":\n if (issue2.values.length === 1)\n return `\\u0110\\u1EA7u v\\xE0o kh\\xF4ng h\\u1EE3p l\\u1EC7: mong \\u0111\\u1EE3i ${stringifyPrimitive(issue2.values[0])}`;\n return `T\\xF9y ch\\u1ECDn kh\\xF4ng h\\u1EE3p l\\u1EC7: mong \\u0111\\u1EE3i m\\u1ED9t trong c\\xE1c gi\\xE1 tr\\u1ECB ${joinValues(issue2.values, \"|\")}`;\n case \"too_big\": {\n const adj = issue2.inclusive ? \"<=\" : \"<\";\n const sizing = getSizing(issue2.origin);\n if (sizing)\n return `Qu\\xE1 l\\u1EDBn: mong \\u0111\\u1EE3i ${issue2.origin ?? \"gi\\xE1 tr\\u1ECB\"} ${sizing.verb} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? \"ph\\u1EA7n t\\u1EED\"}`;\n return `Qu\\xE1 l\\u1EDBn: mong \\u0111\\u1EE3i ${issue2.origin ?? \"gi\\xE1 tr\\u1ECB\"} ${adj}${issue2.maximum.toString()}`;\n }\n case \"too_small\": {\n const adj = issue2.inclusive ? \">=\" : \">\";\n const sizing = getSizing(issue2.origin);\n if (sizing) {\n return `Qu\\xE1 nh\\u1ECF: mong \\u0111\\u1EE3i ${issue2.origin} ${sizing.verb} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;\n }\n return `Qu\\xE1 nh\\u1ECF: mong \\u0111\\u1EE3i ${issue2.origin} ${adj}${issue2.minimum.toString()}`;\n }\n case \"invalid_format\": {\n const _issue = issue2;\n if (_issue.format === \"starts_with\")\n return `Chu\\u1ED7i kh\\xF4ng h\\u1EE3p l\\u1EC7: ph\\u1EA3i b\\u1EAFt \\u0111\\u1EA7u b\\u1EB1ng \"${_issue.prefix}\"`;\n if (_issue.format === \"ends_with\")\n return `Chu\\u1ED7i kh\\xF4ng h\\u1EE3p l\\u1EC7: ph\\u1EA3i k\\u1EBFt th\\xFAc b\\u1EB1ng \"${_issue.suffix}\"`;\n if (_issue.format === \"includes\")\n return `Chu\\u1ED7i kh\\xF4ng h\\u1EE3p l\\u1EC7: ph\\u1EA3i bao g\\u1ED3m \"${_issue.includes}\"`;\n if (_issue.format === \"regex\")\n return `Chu\\u1ED7i kh\\xF4ng h\\u1EE3p l\\u1EC7: ph\\u1EA3i kh\\u1EDBp v\\u1EDBi m\\u1EABu ${_issue.pattern}`;\n return `${FormatDictionary[_issue.format] ?? issue2.format} kh\\xF4ng h\\u1EE3p l\\u1EC7`;\n }\n case \"not_multiple_of\":\n return `S\\u1ED1 kh\\xF4ng h\\u1EE3p l\\u1EC7: ph\\u1EA3i l\\xE0 b\\u1ED9i s\\u1ED1 c\\u1EE7a ${issue2.divisor}`;\n case \"unrecognized_keys\":\n return `Kh\\xF3a kh\\xF4ng \\u0111\\u01B0\\u1EE3c nh\\u1EADn d\\u1EA1ng: ${joinValues(issue2.keys, \", \")}`;\n case \"invalid_key\":\n return `Kh\\xF3a kh\\xF4ng h\\u1EE3p l\\u1EC7 trong ${issue2.origin}`;\n case \"invalid_union\":\n return \"\\u0110\\u1EA7u v\\xE0o kh\\xF4ng h\\u1EE3p l\\u1EC7\";\n case \"invalid_element\":\n return `Gi\\xE1 tr\\u1ECB kh\\xF4ng h\\u1EE3p l\\u1EC7 trong ${issue2.origin}`;\n default:\n return `\\u0110\\u1EA7u v\\xE0o kh\\xF4ng h\\u1EE3p l\\u1EC7`;\n }\n };\n };\n function vi_default() {\n return {\n localeError: error44()\n };\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/zh-CN.js\n var error45 = () => {\n const Sizable = {\n string: { unit: \"\\u5B57\\u7B26\", verb: \"\\u5305\\u542B\" },\n file: { unit: \"\\u5B57\\u8282\", verb: \"\\u5305\\u542B\" },\n array: { unit: \"\\u9879\", verb: \"\\u5305\\u542B\" },\n set: { unit: \"\\u9879\", verb: \"\\u5305\\u542B\" }\n };\n function getSizing(origin) {\n return Sizable[origin] ?? null;\n }\n const FormatDictionary = {\n regex: \"\\u8F93\\u5165\",\n email: \"\\u7535\\u5B50\\u90AE\\u4EF6\",\n url: \"URL\",\n emoji: \"\\u8868\\u60C5\\u7B26\\u53F7\",\n uuid: \"UUID\",\n uuidv4: \"UUIDv4\",\n uuidv6: \"UUIDv6\",\n nanoid: \"nanoid\",\n guid: \"GUID\",\n cuid: \"cuid\",\n cuid2: \"cuid2\",\n ulid: \"ULID\",\n xid: \"XID\",\n ksuid: \"KSUID\",\n datetime: \"ISO\\u65E5\\u671F\\u65F6\\u95F4\",\n date: \"ISO\\u65E5\\u671F\",\n time: \"ISO\\u65F6\\u95F4\",\n duration: \"ISO\\u65F6\\u957F\",\n ipv4: \"IPv4\\u5730\\u5740\",\n ipv6: \"IPv6\\u5730\\u5740\",\n cidrv4: \"IPv4\\u7F51\\u6BB5\",\n cidrv6: \"IPv6\\u7F51\\u6BB5\",\n base64: \"base64\\u7F16\\u7801\\u5B57\\u7B26\\u4E32\",\n base64url: \"base64url\\u7F16\\u7801\\u5B57\\u7B26\\u4E32\",\n json_string: \"JSON\\u5B57\\u7B26\\u4E32\",\n e164: \"E.164\\u53F7\\u7801\",\n jwt: \"JWT\",\n template_literal: \"\\u8F93\\u5165\"\n };\n const TypeDictionary = {\n nan: \"NaN\",\n number: \"\\u6570\\u5B57\",\n array: \"\\u6570\\u7EC4\",\n null: \"\\u7A7A\\u503C(null)\"\n };\n return (issue2) => {\n switch (issue2.code) {\n case \"invalid_type\": {\n const expected = TypeDictionary[issue2.expected] ?? issue2.expected;\n const receivedType = parsedType(issue2.input);\n const received = TypeDictionary[receivedType] ?? receivedType;\n if (/^[A-Z]/.test(issue2.expected)) {\n return `\\u65E0\\u6548\\u8F93\\u5165\\uFF1A\\u671F\\u671B instanceof ${issue2.expected}\\uFF0C\\u5B9E\\u9645\\u63A5\\u6536 ${received}`;\n }\n return `\\u65E0\\u6548\\u8F93\\u5165\\uFF1A\\u671F\\u671B ${expected}\\uFF0C\\u5B9E\\u9645\\u63A5\\u6536 ${received}`;\n }\n case \"invalid_value\":\n if (issue2.values.length === 1)\n return `\\u65E0\\u6548\\u8F93\\u5165\\uFF1A\\u671F\\u671B ${stringifyPrimitive(issue2.values[0])}`;\n return `\\u65E0\\u6548\\u9009\\u9879\\uFF1A\\u671F\\u671B\\u4EE5\\u4E0B\\u4E4B\\u4E00 ${joinValues(issue2.values, \"|\")}`;\n case \"too_big\": {\n const adj = issue2.inclusive ? \"<=\" : \"<\";\n const sizing = getSizing(issue2.origin);\n if (sizing)\n return `\\u6570\\u503C\\u8FC7\\u5927\\uFF1A\\u671F\\u671B ${issue2.origin ?? \"\\u503C\"} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? \"\\u4E2A\\u5143\\u7D20\"}`;\n return `\\u6570\\u503C\\u8FC7\\u5927\\uFF1A\\u671F\\u671B ${issue2.origin ?? \"\\u503C\"} ${adj}${issue2.maximum.toString()}`;\n }\n case \"too_small\": {\n const adj = issue2.inclusive ? \">=\" : \">\";\n const sizing = getSizing(issue2.origin);\n if (sizing) {\n return `\\u6570\\u503C\\u8FC7\\u5C0F\\uFF1A\\u671F\\u671B ${issue2.origin} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;\n }\n return `\\u6570\\u503C\\u8FC7\\u5C0F\\uFF1A\\u671F\\u671B ${issue2.origin} ${adj}${issue2.minimum.toString()}`;\n }\n case \"invalid_format\": {\n const _issue = issue2;\n if (_issue.format === \"starts_with\")\n return `\\u65E0\\u6548\\u5B57\\u7B26\\u4E32\\uFF1A\\u5FC5\\u987B\\u4EE5 \"${_issue.prefix}\" \\u5F00\\u5934`;\n if (_issue.format === \"ends_with\")\n return `\\u65E0\\u6548\\u5B57\\u7B26\\u4E32\\uFF1A\\u5FC5\\u987B\\u4EE5 \"${_issue.suffix}\" \\u7ED3\\u5C3E`;\n if (_issue.format === \"includes\")\n return `\\u65E0\\u6548\\u5B57\\u7B26\\u4E32\\uFF1A\\u5FC5\\u987B\\u5305\\u542B \"${_issue.includes}\"`;\n if (_issue.format === \"regex\")\n return `\\u65E0\\u6548\\u5B57\\u7B26\\u4E32\\uFF1A\\u5FC5\\u987B\\u6EE1\\u8DB3\\u6B63\\u5219\\u8868\\u8FBE\\u5F0F ${_issue.pattern}`;\n return `\\u65E0\\u6548${FormatDictionary[_issue.format] ?? issue2.format}`;\n }\n case \"not_multiple_of\":\n return `\\u65E0\\u6548\\u6570\\u5B57\\uFF1A\\u5FC5\\u987B\\u662F ${issue2.divisor} \\u7684\\u500D\\u6570`;\n case \"unrecognized_keys\":\n return `\\u51FA\\u73B0\\u672A\\u77E5\\u7684\\u952E(key): ${joinValues(issue2.keys, \", \")}`;\n case \"invalid_key\":\n return `${issue2.origin} \\u4E2D\\u7684\\u952E(key)\\u65E0\\u6548`;\n case \"invalid_union\":\n return \"\\u65E0\\u6548\\u8F93\\u5165\";\n case \"invalid_element\":\n return `${issue2.origin} \\u4E2D\\u5305\\u542B\\u65E0\\u6548\\u503C(value)`;\n default:\n return `\\u65E0\\u6548\\u8F93\\u5165`;\n }\n };\n };\n function zh_CN_default() {\n return {\n localeError: error45()\n };\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/zh-TW.js\n var error46 = () => {\n const Sizable = {\n string: { unit: \"\\u5B57\\u5143\", verb: \"\\u64C1\\u6709\" },\n file: { unit: \"\\u4F4D\\u5143\\u7D44\", verb: \"\\u64C1\\u6709\" },\n array: { unit: \"\\u9805\\u76EE\", verb: \"\\u64C1\\u6709\" },\n set: { unit: \"\\u9805\\u76EE\", verb: \"\\u64C1\\u6709\" }\n };\n function getSizing(origin) {\n return Sizable[origin] ?? null;\n }\n const FormatDictionary = {\n regex: \"\\u8F38\\u5165\",\n email: \"\\u90F5\\u4EF6\\u5730\\u5740\",\n url: \"URL\",\n emoji: \"emoji\",\n uuid: \"UUID\",\n uuidv4: \"UUIDv4\",\n uuidv6: \"UUIDv6\",\n nanoid: \"nanoid\",\n guid: \"GUID\",\n cuid: \"cuid\",\n cuid2: \"cuid2\",\n ulid: \"ULID\",\n xid: \"XID\",\n ksuid: \"KSUID\",\n datetime: \"ISO \\u65E5\\u671F\\u6642\\u9593\",\n date: \"ISO \\u65E5\\u671F\",\n time: \"ISO \\u6642\\u9593\",\n duration: \"ISO \\u671F\\u9593\",\n ipv4: \"IPv4 \\u4F4D\\u5740\",\n ipv6: \"IPv6 \\u4F4D\\u5740\",\n cidrv4: \"IPv4 \\u7BC4\\u570D\",\n cidrv6: \"IPv6 \\u7BC4\\u570D\",\n base64: \"base64 \\u7DE8\\u78BC\\u5B57\\u4E32\",\n base64url: \"base64url \\u7DE8\\u78BC\\u5B57\\u4E32\",\n json_string: \"JSON \\u5B57\\u4E32\",\n e164: \"E.164 \\u6578\\u503C\",\n jwt: \"JWT\",\n template_literal: \"\\u8F38\\u5165\"\n };\n const TypeDictionary = {\n nan: \"NaN\"\n };\n return (issue2) => {\n switch (issue2.code) {\n case \"invalid_type\": {\n const expected = TypeDictionary[issue2.expected] ?? issue2.expected;\n const receivedType = parsedType(issue2.input);\n const received = TypeDictionary[receivedType] ?? receivedType;\n if (/^[A-Z]/.test(issue2.expected)) {\n return `\\u7121\\u6548\\u7684\\u8F38\\u5165\\u503C\\uFF1A\\u9810\\u671F\\u70BA instanceof ${issue2.expected}\\uFF0C\\u4F46\\u6536\\u5230 ${received}`;\n }\n return `\\u7121\\u6548\\u7684\\u8F38\\u5165\\u503C\\uFF1A\\u9810\\u671F\\u70BA ${expected}\\uFF0C\\u4F46\\u6536\\u5230 ${received}`;\n }\n case \"invalid_value\":\n if (issue2.values.length === 1)\n return `\\u7121\\u6548\\u7684\\u8F38\\u5165\\u503C\\uFF1A\\u9810\\u671F\\u70BA ${stringifyPrimitive(issue2.values[0])}`;\n return `\\u7121\\u6548\\u7684\\u9078\\u9805\\uFF1A\\u9810\\u671F\\u70BA\\u4EE5\\u4E0B\\u5176\\u4E2D\\u4E4B\\u4E00 ${joinValues(issue2.values, \"|\")}`;\n case \"too_big\": {\n const adj = issue2.inclusive ? \"<=\" : \"<\";\n const sizing = getSizing(issue2.origin);\n if (sizing)\n return `\\u6578\\u503C\\u904E\\u5927\\uFF1A\\u9810\\u671F ${issue2.origin ?? \"\\u503C\"} \\u61C9\\u70BA ${adj}${issue2.maximum.toString()} ${sizing.unit ?? \"\\u500B\\u5143\\u7D20\"}`;\n return `\\u6578\\u503C\\u904E\\u5927\\uFF1A\\u9810\\u671F ${issue2.origin ?? \"\\u503C\"} \\u61C9\\u70BA ${adj}${issue2.maximum.toString()}`;\n }\n case \"too_small\": {\n const adj = issue2.inclusive ? \">=\" : \">\";\n const sizing = getSizing(issue2.origin);\n if (sizing) {\n return `\\u6578\\u503C\\u904E\\u5C0F\\uFF1A\\u9810\\u671F ${issue2.origin} \\u61C9\\u70BA ${adj}${issue2.minimum.toString()} ${sizing.unit}`;\n }\n return `\\u6578\\u503C\\u904E\\u5C0F\\uFF1A\\u9810\\u671F ${issue2.origin} \\u61C9\\u70BA ${adj}${issue2.minimum.toString()}`;\n }\n case \"invalid_format\": {\n const _issue = issue2;\n if (_issue.format === \"starts_with\") {\n return `\\u7121\\u6548\\u7684\\u5B57\\u4E32\\uFF1A\\u5FC5\\u9808\\u4EE5 \"${_issue.prefix}\" \\u958B\\u982D`;\n }\n if (_issue.format === \"ends_with\")\n return `\\u7121\\u6548\\u7684\\u5B57\\u4E32\\uFF1A\\u5FC5\\u9808\\u4EE5 \"${_issue.suffix}\" \\u7D50\\u5C3E`;\n if (_issue.format === \"includes\")\n return `\\u7121\\u6548\\u7684\\u5B57\\u4E32\\uFF1A\\u5FC5\\u9808\\u5305\\u542B \"${_issue.includes}\"`;\n if (_issue.format === \"regex\")\n return `\\u7121\\u6548\\u7684\\u5B57\\u4E32\\uFF1A\\u5FC5\\u9808\\u7B26\\u5408\\u683C\\u5F0F ${_issue.pattern}`;\n return `\\u7121\\u6548\\u7684 ${FormatDictionary[_issue.format] ?? issue2.format}`;\n }\n case \"not_multiple_of\":\n return `\\u7121\\u6548\\u7684\\u6578\\u5B57\\uFF1A\\u5FC5\\u9808\\u70BA ${issue2.divisor} \\u7684\\u500D\\u6578`;\n case \"unrecognized_keys\":\n return `\\u7121\\u6CD5\\u8B58\\u5225\\u7684\\u9375\\u503C${issue2.keys.length > 1 ? \"\\u5011\" : \"\"}\\uFF1A${joinValues(issue2.keys, \"\\u3001\")}`;\n case \"invalid_key\":\n return `${issue2.origin} \\u4E2D\\u6709\\u7121\\u6548\\u7684\\u9375\\u503C`;\n case \"invalid_union\":\n return \"\\u7121\\u6548\\u7684\\u8F38\\u5165\\u503C\";\n case \"invalid_element\":\n return `${issue2.origin} \\u4E2D\\u6709\\u7121\\u6548\\u7684\\u503C`;\n default:\n return `\\u7121\\u6548\\u7684\\u8F38\\u5165\\u503C`;\n }\n };\n };\n function zh_TW_default() {\n return {\n localeError: error46()\n };\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/locales/yo.js\n var error47 = () => {\n const Sizable = {\n string: { unit: \"\\xE0mi\", verb: \"n\\xED\" },\n file: { unit: \"bytes\", verb: \"n\\xED\" },\n array: { unit: \"nkan\", verb: \"n\\xED\" },\n set: { unit: \"nkan\", verb: \"n\\xED\" }\n };\n function getSizing(origin) {\n return Sizable[origin] ?? null;\n }\n const FormatDictionary = {\n regex: \"\\u1EB9\\u0300r\\u1ECD \\xECb\\xE1w\\u1ECDl\\xE9\",\n email: \"\\xE0d\\xEDr\\u1EB9\\u0301s\\xEC \\xECm\\u1EB9\\u0301l\\xEC\",\n url: \"URL\",\n emoji: \"emoji\",\n uuid: \"UUID\",\n uuidv4: \"UUIDv4\",\n uuidv6: \"UUIDv6\",\n nanoid: \"nanoid\",\n guid: \"GUID\",\n cuid: \"cuid\",\n cuid2: \"cuid2\",\n ulid: \"ULID\",\n xid: \"XID\",\n ksuid: \"KSUID\",\n datetime: \"\\xE0k\\xF3k\\xF2 ISO\",\n date: \"\\u1ECDj\\u1ECD\\u0301 ISO\",\n time: \"\\xE0k\\xF3k\\xF2 ISO\",\n duration: \"\\xE0k\\xF3k\\xF2 t\\xF3 p\\xE9 ISO\",\n ipv4: \"\\xE0d\\xEDr\\u1EB9\\u0301s\\xEC IPv4\",\n ipv6: \"\\xE0d\\xEDr\\u1EB9\\u0301s\\xEC IPv6\",\n cidrv4: \"\\xE0gb\\xE8gb\\xE8 IPv4\",\n cidrv6: \"\\xE0gb\\xE8gb\\xE8 IPv6\",\n base64: \"\\u1ECD\\u0300r\\u1ECD\\u0300 t\\xED a k\\u1ECD\\u0301 n\\xED base64\",\n base64url: \"\\u1ECD\\u0300r\\u1ECD\\u0300 base64url\",\n json_string: \"\\u1ECD\\u0300r\\u1ECD\\u0300 JSON\",\n e164: \"n\\u1ECD\\u0301mb\\xE0 E.164\",\n jwt: \"JWT\",\n template_literal: \"\\u1EB9\\u0300r\\u1ECD \\xECb\\xE1w\\u1ECDl\\xE9\"\n };\n const TypeDictionary = {\n nan: \"NaN\",\n number: \"n\\u1ECD\\u0301mb\\xE0\",\n array: \"akop\\u1ECD\"\n };\n return (issue2) => {\n switch (issue2.code) {\n case \"invalid_type\": {\n const expected = TypeDictionary[issue2.expected] ?? issue2.expected;\n const receivedType = parsedType(issue2.input);\n const received = TypeDictionary[receivedType] ?? receivedType;\n if (/^[A-Z]/.test(issue2.expected)) {\n return `\\xCCb\\xE1w\\u1ECDl\\xE9 a\\u1E63\\xEC\\u1E63e: a n\\xED l\\xE1ti fi instanceof ${issue2.expected}, \\xE0m\\u1ECD\\u0300 a r\\xED ${received}`;\n }\n return `\\xCCb\\xE1w\\u1ECDl\\xE9 a\\u1E63\\xEC\\u1E63e: a n\\xED l\\xE1ti fi ${expected}, \\xE0m\\u1ECD\\u0300 a r\\xED ${received}`;\n }\n case \"invalid_value\":\n if (issue2.values.length === 1)\n return `\\xCCb\\xE1w\\u1ECDl\\xE9 a\\u1E63\\xEC\\u1E63e: a n\\xED l\\xE1ti fi ${stringifyPrimitive(issue2.values[0])}`;\n return `\\xC0\\u1E63\\xE0y\\xE0n a\\u1E63\\xEC\\u1E63e: yan \\u1ECD\\u0300kan l\\xE1ra ${joinValues(issue2.values, \"|\")}`;\n case \"too_big\": {\n const adj = issue2.inclusive ? \"<=\" : \"<\";\n const sizing = getSizing(issue2.origin);\n if (sizing)\n return `T\\xF3 p\\u1ECD\\u0300 j\\xF9: a n\\xED l\\xE1ti j\\u1EB9\\u0301 p\\xE9 ${issue2.origin ?? \"iye\"} ${sizing.verb} ${adj}${issue2.maximum} ${sizing.unit}`;\n return `T\\xF3 p\\u1ECD\\u0300 j\\xF9: a n\\xED l\\xE1ti j\\u1EB9\\u0301 ${adj}${issue2.maximum}`;\n }\n case \"too_small\": {\n const adj = issue2.inclusive ? \">=\" : \">\";\n const sizing = getSizing(issue2.origin);\n if (sizing)\n return `K\\xE9r\\xE9 ju: a n\\xED l\\xE1ti j\\u1EB9\\u0301 p\\xE9 ${issue2.origin} ${sizing.verb} ${adj}${issue2.minimum} ${sizing.unit}`;\n return `K\\xE9r\\xE9 ju: a n\\xED l\\xE1ti j\\u1EB9\\u0301 ${adj}${issue2.minimum}`;\n }\n case \"invalid_format\": {\n const _issue = issue2;\n if (_issue.format === \"starts_with\")\n return `\\u1ECC\\u0300r\\u1ECD\\u0300 a\\u1E63\\xEC\\u1E63e: gb\\u1ECD\\u0301d\\u1ECD\\u0300 b\\u1EB9\\u0300r\\u1EB9\\u0300 p\\u1EB9\\u0300l\\xFA \"${_issue.prefix}\"`;\n if (_issue.format === \"ends_with\")\n return `\\u1ECC\\u0300r\\u1ECD\\u0300 a\\u1E63\\xEC\\u1E63e: gb\\u1ECD\\u0301d\\u1ECD\\u0300 par\\xED p\\u1EB9\\u0300l\\xFA \"${_issue.suffix}\"`;\n if (_issue.format === \"includes\")\n return `\\u1ECC\\u0300r\\u1ECD\\u0300 a\\u1E63\\xEC\\u1E63e: gb\\u1ECD\\u0301d\\u1ECD\\u0300 n\\xED \"${_issue.includes}\"`;\n if (_issue.format === \"regex\")\n return `\\u1ECC\\u0300r\\u1ECD\\u0300 a\\u1E63\\xEC\\u1E63e: gb\\u1ECD\\u0301d\\u1ECD\\u0300 b\\xE1 \\xE0p\\u1EB9\\u1EB9r\\u1EB9 mu ${_issue.pattern}`;\n return `A\\u1E63\\xEC\\u1E63e: ${FormatDictionary[_issue.format] ?? issue2.format}`;\n }\n case \"not_multiple_of\":\n return `N\\u1ECD\\u0301mb\\xE0 a\\u1E63\\xEC\\u1E63e: gb\\u1ECD\\u0301d\\u1ECD\\u0300 j\\u1EB9\\u0301 \\xE8y\\xE0 p\\xEDp\\xEDn ti ${issue2.divisor}`;\n case \"unrecognized_keys\":\n return `B\\u1ECDt\\xECn\\xEC \\xE0\\xECm\\u1ECD\\u0300: ${joinValues(issue2.keys, \", \")}`;\n case \"invalid_key\":\n return `B\\u1ECDt\\xECn\\xEC a\\u1E63\\xEC\\u1E63e n\\xEDn\\xFA ${issue2.origin}`;\n case \"invalid_union\":\n return \"\\xCCb\\xE1w\\u1ECDl\\xE9 a\\u1E63\\xEC\\u1E63e\";\n case \"invalid_element\":\n return `Iye a\\u1E63\\xEC\\u1E63e n\\xEDn\\xFA ${issue2.origin}`;\n default:\n return \"\\xCCb\\xE1w\\u1ECDl\\xE9 a\\u1E63\\xEC\\u1E63e\";\n }\n };\n };\n function yo_default() {\n return {\n localeError: error47()\n };\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/registries.js\n var _a;\n var $output = /* @__PURE__ */ Symbol(\"ZodOutput\");\n var $input = /* @__PURE__ */ Symbol(\"ZodInput\");\n var $ZodRegistry = class {\n constructor() {\n this._map = /* @__PURE__ */ new WeakMap();\n this._idmap = /* @__PURE__ */ new Map();\n }\n add(schema, ..._meta) {\n const meta3 = _meta[0];\n this._map.set(schema, meta3);\n if (meta3 && typeof meta3 === \"object\" && \"id\" in meta3) {\n this._idmap.set(meta3.id, schema);\n }\n return this;\n }\n clear() {\n this._map = /* @__PURE__ */ new WeakMap();\n this._idmap = /* @__PURE__ */ new Map();\n return this;\n }\n remove(schema) {\n const meta3 = this._map.get(schema);\n if (meta3 && typeof meta3 === \"object\" && \"id\" in meta3) {\n this._idmap.delete(meta3.id);\n }\n this._map.delete(schema);\n return this;\n }\n get(schema) {\n const p = schema._zod.parent;\n if (p) {\n const pm = { ...this.get(p) ?? {} };\n delete pm.id;\n const f = { ...pm, ...this._map.get(schema) };\n return Object.keys(f).length ? f : void 0;\n }\n return this._map.get(schema);\n }\n has(schema) {\n return this._map.has(schema);\n }\n };\n function registry() {\n return new $ZodRegistry();\n }\n (_a = globalThis).__zod_globalRegistry ?? (_a.__zod_globalRegistry = registry());\n var globalRegistry = globalThis.__zod_globalRegistry;\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/api.js\n // @__NO_SIDE_EFFECTS__\n function _string(Class2, params) {\n return new Class2({\n type: \"string\",\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _coercedString(Class2, params) {\n return new Class2({\n type: \"string\",\n coerce: true,\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _email(Class2, params) {\n return new Class2({\n type: \"string\",\n format: \"email\",\n check: \"string_format\",\n abort: false,\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _guid(Class2, params) {\n return new Class2({\n type: \"string\",\n format: \"guid\",\n check: \"string_format\",\n abort: false,\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _uuid(Class2, params) {\n return new Class2({\n type: \"string\",\n format: \"uuid\",\n check: \"string_format\",\n abort: false,\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _uuidv4(Class2, params) {\n return new Class2({\n type: \"string\",\n format: \"uuid\",\n check: \"string_format\",\n abort: false,\n version: \"v4\",\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _uuidv6(Class2, params) {\n return new Class2({\n type: \"string\",\n format: \"uuid\",\n check: \"string_format\",\n abort: false,\n version: \"v6\",\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _uuidv7(Class2, params) {\n return new Class2({\n type: \"string\",\n format: \"uuid\",\n check: \"string_format\",\n abort: false,\n version: \"v7\",\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _url(Class2, params) {\n return new Class2({\n type: \"string\",\n format: \"url\",\n check: \"string_format\",\n abort: false,\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _emoji2(Class2, params) {\n return new Class2({\n type: \"string\",\n format: \"emoji\",\n check: \"string_format\",\n abort: false,\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _nanoid(Class2, params) {\n return new Class2({\n type: \"string\",\n format: \"nanoid\",\n check: \"string_format\",\n abort: false,\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _cuid(Class2, params) {\n return new Class2({\n type: \"string\",\n format: \"cuid\",\n check: \"string_format\",\n abort: false,\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _cuid2(Class2, params) {\n return new Class2({\n type: \"string\",\n format: \"cuid2\",\n check: \"string_format\",\n abort: false,\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _ulid(Class2, params) {\n return new Class2({\n type: \"string\",\n format: \"ulid\",\n check: \"string_format\",\n abort: false,\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _xid(Class2, params) {\n return new Class2({\n type: \"string\",\n format: \"xid\",\n check: \"string_format\",\n abort: false,\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _ksuid(Class2, params) {\n return new Class2({\n type: \"string\",\n format: \"ksuid\",\n check: \"string_format\",\n abort: false,\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _ipv4(Class2, params) {\n return new Class2({\n type: \"string\",\n format: \"ipv4\",\n check: \"string_format\",\n abort: false,\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _ipv6(Class2, params) {\n return new Class2({\n type: \"string\",\n format: \"ipv6\",\n check: \"string_format\",\n abort: false,\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _mac(Class2, params) {\n return new Class2({\n type: \"string\",\n format: \"mac\",\n check: \"string_format\",\n abort: false,\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _cidrv4(Class2, params) {\n return new Class2({\n type: \"string\",\n format: \"cidrv4\",\n check: \"string_format\",\n abort: false,\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _cidrv6(Class2, params) {\n return new Class2({\n type: \"string\",\n format: \"cidrv6\",\n check: \"string_format\",\n abort: false,\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _base64(Class2, params) {\n return new Class2({\n type: \"string\",\n format: \"base64\",\n check: \"string_format\",\n abort: false,\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _base64url(Class2, params) {\n return new Class2({\n type: \"string\",\n format: \"base64url\",\n check: \"string_format\",\n abort: false,\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _e164(Class2, params) {\n return new Class2({\n type: \"string\",\n format: \"e164\",\n check: \"string_format\",\n abort: false,\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _jwt(Class2, params) {\n return new Class2({\n type: \"string\",\n format: \"jwt\",\n check: \"string_format\",\n abort: false,\n ...normalizeParams(params)\n });\n }\n var TimePrecision = {\n Any: null,\n Minute: -1,\n Second: 0,\n Millisecond: 3,\n Microsecond: 6\n };\n // @__NO_SIDE_EFFECTS__\n function _isoDateTime(Class2, params) {\n return new Class2({\n type: \"string\",\n format: \"datetime\",\n check: \"string_format\",\n offset: false,\n local: false,\n precision: null,\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _isoDate(Class2, params) {\n return new Class2({\n type: \"string\",\n format: \"date\",\n check: \"string_format\",\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _isoTime(Class2, params) {\n return new Class2({\n type: \"string\",\n format: \"time\",\n check: \"string_format\",\n precision: null,\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _isoDuration(Class2, params) {\n return new Class2({\n type: \"string\",\n format: \"duration\",\n check: \"string_format\",\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _number(Class2, params) {\n return new Class2({\n type: \"number\",\n checks: [],\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _coercedNumber(Class2, params) {\n return new Class2({\n type: \"number\",\n coerce: true,\n checks: [],\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _int(Class2, params) {\n return new Class2({\n type: \"number\",\n check: \"number_format\",\n abort: false,\n format: \"safeint\",\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _float32(Class2, params) {\n return new Class2({\n type: \"number\",\n check: \"number_format\",\n abort: false,\n format: \"float32\",\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _float64(Class2, params) {\n return new Class2({\n type: \"number\",\n check: \"number_format\",\n abort: false,\n format: \"float64\",\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _int32(Class2, params) {\n return new Class2({\n type: \"number\",\n check: \"number_format\",\n abort: false,\n format: \"int32\",\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _uint32(Class2, params) {\n return new Class2({\n type: \"number\",\n check: \"number_format\",\n abort: false,\n format: \"uint32\",\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _boolean(Class2, params) {\n return new Class2({\n type: \"boolean\",\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _coercedBoolean(Class2, params) {\n return new Class2({\n type: \"boolean\",\n coerce: true,\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _bigint(Class2, params) {\n return new Class2({\n type: \"bigint\",\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _coercedBigint(Class2, params) {\n return new Class2({\n type: \"bigint\",\n coerce: true,\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _int64(Class2, params) {\n return new Class2({\n type: \"bigint\",\n check: \"bigint_format\",\n abort: false,\n format: \"int64\",\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _uint64(Class2, params) {\n return new Class2({\n type: \"bigint\",\n check: \"bigint_format\",\n abort: false,\n format: \"uint64\",\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _symbol(Class2, params) {\n return new Class2({\n type: \"symbol\",\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _undefined2(Class2, params) {\n return new Class2({\n type: \"undefined\",\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _null2(Class2, params) {\n return new Class2({\n type: \"null\",\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _any(Class2) {\n return new Class2({\n type: \"any\"\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _unknown(Class2) {\n return new Class2({\n type: \"unknown\"\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _never(Class2, params) {\n return new Class2({\n type: \"never\",\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _void(Class2, params) {\n return new Class2({\n type: \"void\",\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _date(Class2, params) {\n return new Class2({\n type: \"date\",\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _coercedDate(Class2, params) {\n return new Class2({\n type: \"date\",\n coerce: true,\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _nan(Class2, params) {\n return new Class2({\n type: \"nan\",\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _lt(value, params) {\n return new $ZodCheckLessThan({\n check: \"less_than\",\n ...normalizeParams(params),\n value,\n inclusive: false\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _lte(value, params) {\n return new $ZodCheckLessThan({\n check: \"less_than\",\n ...normalizeParams(params),\n value,\n inclusive: true\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _gt(value, params) {\n return new $ZodCheckGreaterThan({\n check: \"greater_than\",\n ...normalizeParams(params),\n value,\n inclusive: false\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _gte(value, params) {\n return new $ZodCheckGreaterThan({\n check: \"greater_than\",\n ...normalizeParams(params),\n value,\n inclusive: true\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _positive(params) {\n return /* @__PURE__ */ _gt(0, params);\n }\n // @__NO_SIDE_EFFECTS__\n function _negative(params) {\n return /* @__PURE__ */ _lt(0, params);\n }\n // @__NO_SIDE_EFFECTS__\n function _nonpositive(params) {\n return /* @__PURE__ */ _lte(0, params);\n }\n // @__NO_SIDE_EFFECTS__\n function _nonnegative(params) {\n return /* @__PURE__ */ _gte(0, params);\n }\n // @__NO_SIDE_EFFECTS__\n function _multipleOf(value, params) {\n return new $ZodCheckMultipleOf({\n check: \"multiple_of\",\n ...normalizeParams(params),\n value\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _maxSize(maximum, params) {\n return new $ZodCheckMaxSize({\n check: \"max_size\",\n ...normalizeParams(params),\n maximum\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _minSize(minimum, params) {\n return new $ZodCheckMinSize({\n check: \"min_size\",\n ...normalizeParams(params),\n minimum\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _size(size, params) {\n return new $ZodCheckSizeEquals({\n check: \"size_equals\",\n ...normalizeParams(params),\n size\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _maxLength(maximum, params) {\n const ch = new $ZodCheckMaxLength({\n check: \"max_length\",\n ...normalizeParams(params),\n maximum\n });\n return ch;\n }\n // @__NO_SIDE_EFFECTS__\n function _minLength(minimum, params) {\n return new $ZodCheckMinLength({\n check: \"min_length\",\n ...normalizeParams(params),\n minimum\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _length(length, params) {\n return new $ZodCheckLengthEquals({\n check: \"length_equals\",\n ...normalizeParams(params),\n length\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _regex(pattern, params) {\n return new $ZodCheckRegex({\n check: \"string_format\",\n format: \"regex\",\n ...normalizeParams(params),\n pattern\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _lowercase(params) {\n return new $ZodCheckLowerCase({\n check: \"string_format\",\n format: \"lowercase\",\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _uppercase(params) {\n return new $ZodCheckUpperCase({\n check: \"string_format\",\n format: \"uppercase\",\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _includes(includes, params) {\n return new $ZodCheckIncludes({\n check: \"string_format\",\n format: \"includes\",\n ...normalizeParams(params),\n includes\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _startsWith(prefix, params) {\n return new $ZodCheckStartsWith({\n check: \"string_format\",\n format: \"starts_with\",\n ...normalizeParams(params),\n prefix\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _endsWith(suffix, params) {\n return new $ZodCheckEndsWith({\n check: \"string_format\",\n format: \"ends_with\",\n ...normalizeParams(params),\n suffix\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _property(property, schema, params) {\n return new $ZodCheckProperty({\n check: \"property\",\n property,\n schema,\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _mime(types, params) {\n return new $ZodCheckMimeType({\n check: \"mime_type\",\n mime: types,\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _overwrite(tx) {\n return new $ZodCheckOverwrite({\n check: \"overwrite\",\n tx\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _normalize(form) {\n return /* @__PURE__ */ _overwrite((input) => input.normalize(form));\n }\n // @__NO_SIDE_EFFECTS__\n function _trim() {\n return /* @__PURE__ */ _overwrite((input) => input.trim());\n }\n // @__NO_SIDE_EFFECTS__\n function _toLowerCase() {\n return /* @__PURE__ */ _overwrite((input) => input.toLowerCase());\n }\n // @__NO_SIDE_EFFECTS__\n function _toUpperCase() {\n return /* @__PURE__ */ _overwrite((input) => input.toUpperCase());\n }\n // @__NO_SIDE_EFFECTS__\n function _slugify() {\n return /* @__PURE__ */ _overwrite((input) => slugify(input));\n }\n // @__NO_SIDE_EFFECTS__\n function _array(Class2, element, params) {\n return new Class2({\n type: \"array\",\n element,\n // get element() {\n // return element;\n // },\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _union(Class2, options, params) {\n return new Class2({\n type: \"union\",\n options,\n ...normalizeParams(params)\n });\n }\n function _xor(Class2, options, params) {\n return new Class2({\n type: \"union\",\n options,\n inclusive: false,\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _discriminatedUnion(Class2, discriminator, options, params) {\n return new Class2({\n type: \"union\",\n options,\n discriminator,\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _intersection(Class2, left, right) {\n return new Class2({\n type: \"intersection\",\n left,\n right\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _tuple(Class2, items, _paramsOrRest, _params) {\n const hasRest = _paramsOrRest instanceof $ZodType;\n const params = hasRest ? _params : _paramsOrRest;\n const rest = hasRest ? _paramsOrRest : null;\n return new Class2({\n type: \"tuple\",\n items,\n rest,\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _record(Class2, keyType, valueType, params) {\n return new Class2({\n type: \"record\",\n keyType,\n valueType,\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _map(Class2, keyType, valueType, params) {\n return new Class2({\n type: \"map\",\n keyType,\n valueType,\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _set(Class2, valueType, params) {\n return new Class2({\n type: \"set\",\n valueType,\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _enum(Class2, values, params) {\n const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;\n return new Class2({\n type: \"enum\",\n entries,\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _nativeEnum(Class2, entries, params) {\n return new Class2({\n type: \"enum\",\n entries,\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _literal(Class2, value, params) {\n return new Class2({\n type: \"literal\",\n values: Array.isArray(value) ? value : [value],\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _file(Class2, params) {\n return new Class2({\n type: \"file\",\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _transform(Class2, fn) {\n return new Class2({\n type: \"transform\",\n transform: fn\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _optional(Class2, innerType) {\n return new Class2({\n type: \"optional\",\n innerType\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _nullable(Class2, innerType) {\n return new Class2({\n type: \"nullable\",\n innerType\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _default(Class2, innerType, defaultValue) {\n return new Class2({\n type: \"default\",\n innerType,\n get defaultValue() {\n return typeof defaultValue === \"function\" ? defaultValue() : shallowClone(defaultValue);\n }\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _nonoptional(Class2, innerType, params) {\n return new Class2({\n type: \"nonoptional\",\n innerType,\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _success(Class2, innerType) {\n return new Class2({\n type: \"success\",\n innerType\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _catch(Class2, innerType, catchValue) {\n return new Class2({\n type: \"catch\",\n innerType,\n catchValue: typeof catchValue === \"function\" ? catchValue : () => catchValue\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _pipe(Class2, in_, out) {\n return new Class2({\n type: \"pipe\",\n in: in_,\n out\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _readonly(Class2, innerType) {\n return new Class2({\n type: \"readonly\",\n innerType\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _templateLiteral(Class2, parts, params) {\n return new Class2({\n type: \"template_literal\",\n parts,\n ...normalizeParams(params)\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _lazy(Class2, getter) {\n return new Class2({\n type: \"lazy\",\n getter\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _promise(Class2, innerType) {\n return new Class2({\n type: \"promise\",\n innerType\n });\n }\n // @__NO_SIDE_EFFECTS__\n function _custom(Class2, fn, _params) {\n const norm = normalizeParams(_params);\n norm.abort ?? (norm.abort = true);\n const schema = new Class2({\n type: \"custom\",\n check: \"custom\",\n fn,\n ...norm\n });\n return schema;\n }\n // @__NO_SIDE_EFFECTS__\n function _refine(Class2, fn, _params) {\n const schema = new Class2({\n type: \"custom\",\n check: \"custom\",\n fn,\n ...normalizeParams(_params)\n });\n return schema;\n }\n // @__NO_SIDE_EFFECTS__\n function _superRefine(fn) {\n const ch = /* @__PURE__ */ _check((payload) => {\n payload.addIssue = (issue2) => {\n if (typeof issue2 === \"string\") {\n payload.issues.push(issue(issue2, payload.value, ch._zod.def));\n } else {\n const _issue = issue2;\n if (_issue.fatal)\n _issue.continue = false;\n _issue.code ?? (_issue.code = \"custom\");\n _issue.input ?? (_issue.input = payload.value);\n _issue.inst ?? (_issue.inst = ch);\n _issue.continue ?? (_issue.continue = !ch._zod.def.abort);\n payload.issues.push(issue(_issue));\n }\n };\n return fn(payload.value, payload);\n });\n return ch;\n }\n // @__NO_SIDE_EFFECTS__\n function _check(fn, params) {\n const ch = new $ZodCheck({\n check: \"custom\",\n ...normalizeParams(params)\n });\n ch._zod.check = fn;\n return ch;\n }\n // @__NO_SIDE_EFFECTS__\n function describe(description) {\n const ch = new $ZodCheck({ check: \"describe\" });\n ch._zod.onattach = [\n (inst) => {\n const existing = globalRegistry.get(inst) ?? {};\n globalRegistry.add(inst, { ...existing, description });\n }\n ];\n ch._zod.check = () => {\n };\n return ch;\n }\n // @__NO_SIDE_EFFECTS__\n function meta(metadata) {\n const ch = new $ZodCheck({ check: \"meta\" });\n ch._zod.onattach = [\n (inst) => {\n const existing = globalRegistry.get(inst) ?? {};\n globalRegistry.add(inst, { ...existing, ...metadata });\n }\n ];\n ch._zod.check = () => {\n };\n return ch;\n }\n // @__NO_SIDE_EFFECTS__\n function _stringbool(Classes, _params) {\n const params = normalizeParams(_params);\n let truthyArray = params.truthy ?? [\"true\", \"1\", \"yes\", \"on\", \"y\", \"enabled\"];\n let falsyArray = params.falsy ?? [\"false\", \"0\", \"no\", \"off\", \"n\", \"disabled\"];\n if (params.case !== \"sensitive\") {\n truthyArray = truthyArray.map((v) => typeof v === \"string\" ? v.toLowerCase() : v);\n falsyArray = falsyArray.map((v) => typeof v === \"string\" ? v.toLowerCase() : v);\n }\n const truthySet = new Set(truthyArray);\n const falsySet = new Set(falsyArray);\n const _Codec = Classes.Codec ?? $ZodCodec;\n const _Boolean = Classes.Boolean ?? $ZodBoolean;\n const _String = Classes.String ?? $ZodString;\n const stringSchema = new _String({ type: \"string\", error: params.error });\n const booleanSchema = new _Boolean({ type: \"boolean\", error: params.error });\n const codec2 = new _Codec({\n type: \"pipe\",\n in: stringSchema,\n out: booleanSchema,\n transform: ((input, payload) => {\n let data = input;\n if (params.case !== \"sensitive\")\n data = data.toLowerCase();\n if (truthySet.has(data)) {\n return true;\n } else if (falsySet.has(data)) {\n return false;\n } else {\n payload.issues.push({\n code: \"invalid_value\",\n expected: \"stringbool\",\n values: [...truthySet, ...falsySet],\n input: payload.value,\n inst: codec2,\n continue: false\n });\n return {};\n }\n }),\n reverseTransform: ((input, _payload) => {\n if (input === true) {\n return truthyArray[0] || \"true\";\n } else {\n return falsyArray[0] || \"false\";\n }\n }),\n error: params.error\n });\n return codec2;\n }\n // @__NO_SIDE_EFFECTS__\n function _stringFormat(Class2, format, fnOrRegex, _params = {}) {\n const params = normalizeParams(_params);\n const def = {\n ...normalizeParams(_params),\n check: \"string_format\",\n type: \"string\",\n format,\n fn: typeof fnOrRegex === \"function\" ? fnOrRegex : (val) => fnOrRegex.test(val),\n ...params\n };\n if (fnOrRegex instanceof RegExp) {\n def.pattern = fnOrRegex;\n }\n const inst = new Class2(def);\n return inst;\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/to-json-schema.js\n function initializeContext(params) {\n let target = params?.target ?? \"draft-2020-12\";\n if (target === \"draft-4\")\n target = \"draft-04\";\n if (target === \"draft-7\")\n target = \"draft-07\";\n return {\n processors: params.processors ?? {},\n metadataRegistry: params?.metadata ?? globalRegistry,\n target,\n unrepresentable: params?.unrepresentable ?? \"throw\",\n override: params?.override ?? (() => {\n }),\n io: params?.io ?? \"output\",\n counter: 0,\n seen: /* @__PURE__ */ new Map(),\n cycles: params?.cycles ?? \"ref\",\n reused: params?.reused ?? \"inline\",\n external: params?.external ?? void 0\n };\n }\n function process(schema, ctx, _params = { path: [], schemaPath: [] }) {\n var _a2;\n const def = schema._zod.def;\n const seen = ctx.seen.get(schema);\n if (seen) {\n seen.count++;\n const isCycle = _params.schemaPath.includes(schema);\n if (isCycle) {\n seen.cycle = _params.path;\n }\n return seen.schema;\n }\n const result = { schema: {}, count: 1, cycle: void 0, path: _params.path };\n ctx.seen.set(schema, result);\n const overrideSchema = schema._zod.toJSONSchema?.();\n if (overrideSchema) {\n result.schema = overrideSchema;\n } else {\n const params = {\n ..._params,\n schemaPath: [..._params.schemaPath, schema],\n path: _params.path\n };\n if (schema._zod.processJSONSchema) {\n schema._zod.processJSONSchema(ctx, result.schema, params);\n } else {\n const _json = result.schema;\n const processor = ctx.processors[def.type];\n if (!processor) {\n throw new Error(`[toJSONSchema]: Non-representable type encountered: ${def.type}`);\n }\n processor(schema, ctx, _json, params);\n }\n const parent = schema._zod.parent;\n if (parent) {\n if (!result.ref)\n result.ref = parent;\n process(parent, ctx, params);\n ctx.seen.get(parent).isParent = true;\n }\n }\n const meta3 = ctx.metadataRegistry.get(schema);\n if (meta3)\n Object.assign(result.schema, meta3);\n if (ctx.io === \"input\" && isTransforming(schema)) {\n delete result.schema.examples;\n delete result.schema.default;\n }\n if (ctx.io === \"input\" && result.schema._prefault)\n (_a2 = result.schema).default ?? (_a2.default = result.schema._prefault);\n delete result.schema._prefault;\n const _result = ctx.seen.get(schema);\n return _result.schema;\n }\n function extractDefs(ctx, schema) {\n const root = ctx.seen.get(schema);\n if (!root)\n throw new Error(\"Unprocessed schema. This is a bug in Zod.\");\n const idToSchema = /* @__PURE__ */ new Map();\n for (const entry of ctx.seen.entries()) {\n const id = ctx.metadataRegistry.get(entry[0])?.id;\n if (id) {\n const existing = idToSchema.get(id);\n if (existing && existing !== entry[0]) {\n throw new Error(`Duplicate schema id \"${id}\" detected during JSON Schema conversion. Two different schemas cannot share the same id when converted together.`);\n }\n idToSchema.set(id, entry[0]);\n }\n }\n const makeURI = (entry) => {\n const defsSegment = ctx.target === \"draft-2020-12\" ? \"$defs\" : \"definitions\";\n if (ctx.external) {\n const externalId = ctx.external.registry.get(entry[0])?.id;\n const uriGenerator = ctx.external.uri ?? ((id2) => id2);\n if (externalId) {\n return { ref: uriGenerator(externalId) };\n }\n const id = entry[1].defId ?? entry[1].schema.id ?? `schema${ctx.counter++}`;\n entry[1].defId = id;\n return { defId: id, ref: `${uriGenerator(\"__shared\")}#/${defsSegment}/${id}` };\n }\n if (entry[1] === root) {\n return { ref: \"#\" };\n }\n const uriPrefix = `#`;\n const defUriPrefix = `${uriPrefix}/${defsSegment}/`;\n const defId = entry[1].schema.id ?? `__schema${ctx.counter++}`;\n return { defId, ref: defUriPrefix + defId };\n };\n const extractToDef = (entry) => {\n if (entry[1].schema.$ref) {\n return;\n }\n const seen = entry[1];\n const { ref, defId } = makeURI(entry);\n seen.def = { ...seen.schema };\n if (defId)\n seen.defId = defId;\n const schema2 = seen.schema;\n for (const key in schema2) {\n delete schema2[key];\n }\n schema2.$ref = ref;\n };\n if (ctx.cycles === \"throw\") {\n for (const entry of ctx.seen.entries()) {\n const seen = entry[1];\n if (seen.cycle) {\n throw new Error(`Cycle detected: #/${seen.cycle?.join(\"/\")}/\n\nSet the \\`cycles\\` parameter to \\`\"ref\"\\` to resolve cyclical schemas with defs.`);\n }\n }\n }\n for (const entry of ctx.seen.entries()) {\n const seen = entry[1];\n if (schema === entry[0]) {\n extractToDef(entry);\n continue;\n }\n if (ctx.external) {\n const ext = ctx.external.registry.get(entry[0])?.id;\n if (schema !== entry[0] && ext) {\n extractToDef(entry);\n continue;\n }\n }\n const id = ctx.metadataRegistry.get(entry[0])?.id;\n if (id) {\n extractToDef(entry);\n continue;\n }\n if (seen.cycle) {\n extractToDef(entry);\n continue;\n }\n if (seen.count > 1) {\n if (ctx.reused === \"ref\") {\n extractToDef(entry);\n continue;\n }\n }\n }\n }\n function finalize(ctx, schema) {\n const root = ctx.seen.get(schema);\n if (!root)\n throw new Error(\"Unprocessed schema. This is a bug in Zod.\");\n const flattenRef = (zodSchema) => {\n const seen = ctx.seen.get(zodSchema);\n if (seen.ref === null)\n return;\n const schema2 = seen.def ?? seen.schema;\n const _cached = { ...schema2 };\n const ref = seen.ref;\n seen.ref = null;\n if (ref) {\n flattenRef(ref);\n const refSeen = ctx.seen.get(ref);\n const refSchema = refSeen.schema;\n if (refSchema.$ref && (ctx.target === \"draft-07\" || ctx.target === \"draft-04\" || ctx.target === \"openapi-3.0\")) {\n schema2.allOf = schema2.allOf ?? [];\n schema2.allOf.push(refSchema);\n } else {\n Object.assign(schema2, refSchema);\n }\n Object.assign(schema2, _cached);\n const isParentRef = zodSchema._zod.parent === ref;\n if (isParentRef) {\n for (const key in schema2) {\n if (key === \"$ref\" || key === \"allOf\")\n continue;\n if (!(key in _cached)) {\n delete schema2[key];\n }\n }\n }\n if (refSchema.$ref && refSeen.def) {\n for (const key in schema2) {\n if (key === \"$ref\" || key === \"allOf\")\n continue;\n if (key in refSeen.def && JSON.stringify(schema2[key]) === JSON.stringify(refSeen.def[key])) {\n delete schema2[key];\n }\n }\n }\n }\n const parent = zodSchema._zod.parent;\n if (parent && parent !== ref) {\n flattenRef(parent);\n const parentSeen = ctx.seen.get(parent);\n if (parentSeen?.schema.$ref) {\n schema2.$ref = parentSeen.schema.$ref;\n if (parentSeen.def) {\n for (const key in schema2) {\n if (key === \"$ref\" || key === \"allOf\")\n continue;\n if (key in parentSeen.def && JSON.stringify(schema2[key]) === JSON.stringify(parentSeen.def[key])) {\n delete schema2[key];\n }\n }\n }\n }\n }\n ctx.override({\n zodSchema,\n jsonSchema: schema2,\n path: seen.path ?? []\n });\n };\n for (const entry of [...ctx.seen.entries()].reverse()) {\n flattenRef(entry[0]);\n }\n const result = {};\n if (ctx.target === \"draft-2020-12\") {\n result.$schema = \"https://json-schema.org/draft/2020-12/schema\";\n } else if (ctx.target === \"draft-07\") {\n result.$schema = \"http://json-schema.org/draft-07/schema#\";\n } else if (ctx.target === \"draft-04\") {\n result.$schema = \"http://json-schema.org/draft-04/schema#\";\n } else if (ctx.target === \"openapi-3.0\") {\n } else {\n }\n if (ctx.external?.uri) {\n const id = ctx.external.registry.get(schema)?.id;\n if (!id)\n throw new Error(\"Schema is missing an `id` property\");\n result.$id = ctx.external.uri(id);\n }\n Object.assign(result, root.def ?? root.schema);\n const defs = ctx.external?.defs ?? {};\n for (const entry of ctx.seen.entries()) {\n const seen = entry[1];\n if (seen.def && seen.defId) {\n defs[seen.defId] = seen.def;\n }\n }\n if (ctx.external) {\n } else {\n if (Object.keys(defs).length > 0) {\n if (ctx.target === \"draft-2020-12\") {\n result.$defs = defs;\n } else {\n result.definitions = defs;\n }\n }\n }\n try {\n const finalized = JSON.parse(JSON.stringify(result));\n Object.defineProperty(finalized, \"~standard\", {\n value: {\n ...schema[\"~standard\"],\n jsonSchema: {\n input: createStandardJSONSchemaMethod(schema, \"input\", ctx.processors),\n output: createStandardJSONSchemaMethod(schema, \"output\", ctx.processors)\n }\n },\n enumerable: false,\n writable: false\n });\n return finalized;\n } catch (_err) {\n throw new Error(\"Error converting schema to JSON.\");\n }\n }\n function isTransforming(_schema, _ctx) {\n const ctx = _ctx ?? { seen: /* @__PURE__ */ new Set() };\n if (ctx.seen.has(_schema))\n return false;\n ctx.seen.add(_schema);\n const def = _schema._zod.def;\n if (def.type === \"transform\")\n return true;\n if (def.type === \"array\")\n return isTransforming(def.element, ctx);\n if (def.type === \"set\")\n return isTransforming(def.valueType, ctx);\n if (def.type === \"lazy\")\n return isTransforming(def.getter(), ctx);\n if (def.type === \"promise\" || def.type === \"optional\" || def.type === \"nonoptional\" || def.type === \"nullable\" || def.type === \"readonly\" || def.type === \"default\" || def.type === \"prefault\") {\n return isTransforming(def.innerType, ctx);\n }\n if (def.type === \"intersection\") {\n return isTransforming(def.left, ctx) || isTransforming(def.right, ctx);\n }\n if (def.type === \"record\" || def.type === \"map\") {\n return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);\n }\n if (def.type === \"pipe\") {\n return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);\n }\n if (def.type === \"object\") {\n for (const key in def.shape) {\n if (isTransforming(def.shape[key], ctx))\n return true;\n }\n return false;\n }\n if (def.type === \"union\") {\n for (const option of def.options) {\n if (isTransforming(option, ctx))\n return true;\n }\n return false;\n }\n if (def.type === \"tuple\") {\n for (const item of def.items) {\n if (isTransforming(item, ctx))\n return true;\n }\n if (def.rest && isTransforming(def.rest, ctx))\n return true;\n return false;\n }\n return false;\n }\n var createToJSONSchemaMethod = (schema, processors = {}) => (params) => {\n const ctx = initializeContext({ ...params, processors });\n process(schema, ctx);\n extractDefs(ctx, schema);\n return finalize(ctx, schema);\n };\n var createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params) => {\n const { libraryOptions, target } = params ?? {};\n const ctx = initializeContext({ ...libraryOptions ?? {}, target, io, processors });\n process(schema, ctx);\n extractDefs(ctx, schema);\n return finalize(ctx, schema);\n };\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/json-schema-processors.js\n var formatMap = {\n guid: \"uuid\",\n url: \"uri\",\n datetime: \"date-time\",\n json_string: \"json-string\",\n regex: \"\"\n // do not set\n };\n var stringProcessor = (schema, ctx, _json, _params) => {\n const json2 = _json;\n json2.type = \"string\";\n const { minimum, maximum, format, patterns, contentEncoding } = schema._zod.bag;\n if (typeof minimum === \"number\")\n json2.minLength = minimum;\n if (typeof maximum === \"number\")\n json2.maxLength = maximum;\n if (format) {\n json2.format = formatMap[format] ?? format;\n if (json2.format === \"\")\n delete json2.format;\n if (format === \"time\") {\n delete json2.format;\n }\n }\n if (contentEncoding)\n json2.contentEncoding = contentEncoding;\n if (patterns && patterns.size > 0) {\n const regexes = [...patterns];\n if (regexes.length === 1)\n json2.pattern = regexes[0].source;\n else if (regexes.length > 1) {\n json2.allOf = [\n ...regexes.map((regex) => ({\n ...ctx.target === \"draft-07\" || ctx.target === \"draft-04\" || ctx.target === \"openapi-3.0\" ? { type: \"string\" } : {},\n pattern: regex.source\n }))\n ];\n }\n }\n };\n var numberProcessor = (schema, ctx, _json, _params) => {\n const json2 = _json;\n const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag;\n if (typeof format === \"string\" && format.includes(\"int\"))\n json2.type = \"integer\";\n else\n json2.type = \"number\";\n if (typeof exclusiveMinimum === \"number\") {\n if (ctx.target === \"draft-04\" || ctx.target === \"openapi-3.0\") {\n json2.minimum = exclusiveMinimum;\n json2.exclusiveMinimum = true;\n } else {\n json2.exclusiveMinimum = exclusiveMinimum;\n }\n }\n if (typeof minimum === \"number\") {\n json2.minimum = minimum;\n if (typeof exclusiveMinimum === \"number\" && ctx.target !== \"draft-04\") {\n if (exclusiveMinimum >= minimum)\n delete json2.minimum;\n else\n delete json2.exclusiveMinimum;\n }\n }\n if (typeof exclusiveMaximum === \"number\") {\n if (ctx.target === \"draft-04\" || ctx.target === \"openapi-3.0\") {\n json2.maximum = exclusiveMaximum;\n json2.exclusiveMaximum = true;\n } else {\n json2.exclusiveMaximum = exclusiveMaximum;\n }\n }\n if (typeof maximum === \"number\") {\n json2.maximum = maximum;\n if (typeof exclusiveMaximum === \"number\" && ctx.target !== \"draft-04\") {\n if (exclusiveMaximum <= maximum)\n delete json2.maximum;\n else\n delete json2.exclusiveMaximum;\n }\n }\n if (typeof multipleOf === \"number\")\n json2.multipleOf = multipleOf;\n };\n var booleanProcessor = (_schema, _ctx, json2, _params) => {\n json2.type = \"boolean\";\n };\n var bigintProcessor = (_schema, ctx, _json, _params) => {\n if (ctx.unrepresentable === \"throw\") {\n throw new Error(\"BigInt cannot be represented in JSON Schema\");\n }\n };\n var symbolProcessor = (_schema, ctx, _json, _params) => {\n if (ctx.unrepresentable === \"throw\") {\n throw new Error(\"Symbols cannot be represented in JSON Schema\");\n }\n };\n var nullProcessor = (_schema, ctx, json2, _params) => {\n if (ctx.target === \"openapi-3.0\") {\n json2.type = \"string\";\n json2.nullable = true;\n json2.enum = [null];\n } else {\n json2.type = \"null\";\n }\n };\n var undefinedProcessor = (_schema, ctx, _json, _params) => {\n if (ctx.unrepresentable === \"throw\") {\n throw new Error(\"Undefined cannot be represented in JSON Schema\");\n }\n };\n var voidProcessor = (_schema, ctx, _json, _params) => {\n if (ctx.unrepresentable === \"throw\") {\n throw new Error(\"Void cannot be represented in JSON Schema\");\n }\n };\n var neverProcessor = (_schema, _ctx, json2, _params) => {\n json2.not = {};\n };\n var anyProcessor = (_schema, _ctx, _json, _params) => {\n };\n var unknownProcessor = (_schema, _ctx, _json, _params) => {\n };\n var dateProcessor = (_schema, ctx, _json, _params) => {\n if (ctx.unrepresentable === \"throw\") {\n throw new Error(\"Date cannot be represented in JSON Schema\");\n }\n };\n var enumProcessor = (schema, _ctx, json2, _params) => {\n const def = schema._zod.def;\n const values = getEnumValues(def.entries);\n if (values.every((v) => typeof v === \"number\"))\n json2.type = \"number\";\n if (values.every((v) => typeof v === \"string\"))\n json2.type = \"string\";\n json2.enum = values;\n };\n var literalProcessor = (schema, ctx, json2, _params) => {\n const def = schema._zod.def;\n const vals = [];\n for (const val of def.values) {\n if (val === void 0) {\n if (ctx.unrepresentable === \"throw\") {\n throw new Error(\"Literal `undefined` cannot be represented in JSON Schema\");\n } else {\n }\n } else if (typeof val === \"bigint\") {\n if (ctx.unrepresentable === \"throw\") {\n throw new Error(\"BigInt literals cannot be represented in JSON Schema\");\n } else {\n vals.push(Number(val));\n }\n } else {\n vals.push(val);\n }\n }\n if (vals.length === 0) {\n } else if (vals.length === 1) {\n const val = vals[0];\n json2.type = val === null ? \"null\" : typeof val;\n if (ctx.target === \"draft-04\" || ctx.target === \"openapi-3.0\") {\n json2.enum = [val];\n } else {\n json2.const = val;\n }\n } else {\n if (vals.every((v) => typeof v === \"number\"))\n json2.type = \"number\";\n if (vals.every((v) => typeof v === \"string\"))\n json2.type = \"string\";\n if (vals.every((v) => typeof v === \"boolean\"))\n json2.type = \"boolean\";\n if (vals.every((v) => v === null))\n json2.type = \"null\";\n json2.enum = vals;\n }\n };\n var nanProcessor = (_schema, ctx, _json, _params) => {\n if (ctx.unrepresentable === \"throw\") {\n throw new Error(\"NaN cannot be represented in JSON Schema\");\n }\n };\n var templateLiteralProcessor = (schema, _ctx, json2, _params) => {\n const _json = json2;\n const pattern = schema._zod.pattern;\n if (!pattern)\n throw new Error(\"Pattern not found in template literal\");\n _json.type = \"string\";\n _json.pattern = pattern.source;\n };\n var fileProcessor = (schema, _ctx, json2, _params) => {\n const _json = json2;\n const file2 = {\n type: \"string\",\n format: \"binary\",\n contentEncoding: \"binary\"\n };\n const { minimum, maximum, mime } = schema._zod.bag;\n if (minimum !== void 0)\n file2.minLength = minimum;\n if (maximum !== void 0)\n file2.maxLength = maximum;\n if (mime) {\n if (mime.length === 1) {\n file2.contentMediaType = mime[0];\n Object.assign(_json, file2);\n } else {\n Object.assign(_json, file2);\n _json.anyOf = mime.map((m) => ({ contentMediaType: m }));\n }\n } else {\n Object.assign(_json, file2);\n }\n };\n var successProcessor = (_schema, _ctx, json2, _params) => {\n json2.type = \"boolean\";\n };\n var customProcessor = (_schema, ctx, _json, _params) => {\n if (ctx.unrepresentable === \"throw\") {\n throw new Error(\"Custom types cannot be represented in JSON Schema\");\n }\n };\n var functionProcessor = (_schema, ctx, _json, _params) => {\n if (ctx.unrepresentable === \"throw\") {\n throw new Error(\"Function types cannot be represented in JSON Schema\");\n }\n };\n var transformProcessor = (_schema, ctx, _json, _params) => {\n if (ctx.unrepresentable === \"throw\") {\n throw new Error(\"Transforms cannot be represented in JSON Schema\");\n }\n };\n var mapProcessor = (_schema, ctx, _json, _params) => {\n if (ctx.unrepresentable === \"throw\") {\n throw new Error(\"Map cannot be represented in JSON Schema\");\n }\n };\n var setProcessor = (_schema, ctx, _json, _params) => {\n if (ctx.unrepresentable === \"throw\") {\n throw new Error(\"Set cannot be represented in JSON Schema\");\n }\n };\n var arrayProcessor = (schema, ctx, _json, params) => {\n const json2 = _json;\n const def = schema._zod.def;\n const { minimum, maximum } = schema._zod.bag;\n if (typeof minimum === \"number\")\n json2.minItems = minimum;\n if (typeof maximum === \"number\")\n json2.maxItems = maximum;\n json2.type = \"array\";\n json2.items = process(def.element, ctx, { ...params, path: [...params.path, \"items\"] });\n };\n var objectProcessor = (schema, ctx, _json, params) => {\n const json2 = _json;\n const def = schema._zod.def;\n json2.type = \"object\";\n json2.properties = {};\n const shape = def.shape;\n for (const key in shape) {\n json2.properties[key] = process(shape[key], ctx, {\n ...params,\n path: [...params.path, \"properties\", key]\n });\n }\n const allKeys = new Set(Object.keys(shape));\n const requiredKeys = new Set([...allKeys].filter((key) => {\n const v = def.shape[key]._zod;\n if (ctx.io === \"input\") {\n return v.optin === void 0;\n } else {\n return v.optout === void 0;\n }\n }));\n if (requiredKeys.size > 0) {\n json2.required = Array.from(requiredKeys);\n }\n if (def.catchall?._zod.def.type === \"never\") {\n json2.additionalProperties = false;\n } else if (!def.catchall) {\n if (ctx.io === \"output\")\n json2.additionalProperties = false;\n } else if (def.catchall) {\n json2.additionalProperties = process(def.catchall, ctx, {\n ...params,\n path: [...params.path, \"additionalProperties\"]\n });\n }\n };\n var unionProcessor = (schema, ctx, json2, params) => {\n const def = schema._zod.def;\n const isExclusive = def.inclusive === false;\n const options = def.options.map((x, i) => process(x, ctx, {\n ...params,\n path: [...params.path, isExclusive ? \"oneOf\" : \"anyOf\", i]\n }));\n if (isExclusive) {\n json2.oneOf = options;\n } else {\n json2.anyOf = options;\n }\n };\n var intersectionProcessor = (schema, ctx, json2, params) => {\n const def = schema._zod.def;\n const a = process(def.left, ctx, {\n ...params,\n path: [...params.path, \"allOf\", 0]\n });\n const b = process(def.right, ctx, {\n ...params,\n path: [...params.path, \"allOf\", 1]\n });\n const isSimpleIntersection = (val) => \"allOf\" in val && Object.keys(val).length === 1;\n const allOf = [\n ...isSimpleIntersection(a) ? a.allOf : [a],\n ...isSimpleIntersection(b) ? b.allOf : [b]\n ];\n json2.allOf = allOf;\n };\n var tupleProcessor = (schema, ctx, _json, params) => {\n const json2 = _json;\n const def = schema._zod.def;\n json2.type = \"array\";\n const prefixPath2 = ctx.target === \"draft-2020-12\" ? \"prefixItems\" : \"items\";\n const restPath = ctx.target === \"draft-2020-12\" ? \"items\" : ctx.target === \"openapi-3.0\" ? \"items\" : \"additionalItems\";\n const prefixItems = def.items.map((x, i) => process(x, ctx, {\n ...params,\n path: [...params.path, prefixPath2, i]\n }));\n const rest = def.rest ? process(def.rest, ctx, {\n ...params,\n path: [...params.path, restPath, ...ctx.target === \"openapi-3.0\" ? [def.items.length] : []]\n }) : null;\n if (ctx.target === \"draft-2020-12\") {\n json2.prefixItems = prefixItems;\n if (rest) {\n json2.items = rest;\n }\n } else if (ctx.target === \"openapi-3.0\") {\n json2.items = {\n anyOf: prefixItems\n };\n if (rest) {\n json2.items.anyOf.push(rest);\n }\n json2.minItems = prefixItems.length;\n if (!rest) {\n json2.maxItems = prefixItems.length;\n }\n } else {\n json2.items = prefixItems;\n if (rest) {\n json2.additionalItems = rest;\n }\n }\n const { minimum, maximum } = schema._zod.bag;\n if (typeof minimum === \"number\")\n json2.minItems = minimum;\n if (typeof maximum === \"number\")\n json2.maxItems = maximum;\n };\n var recordProcessor = (schema, ctx, _json, params) => {\n const json2 = _json;\n const def = schema._zod.def;\n json2.type = \"object\";\n const keyType = def.keyType;\n const keyBag = keyType._zod.bag;\n const patterns = keyBag?.patterns;\n if (def.mode === \"loose\" && patterns && patterns.size > 0) {\n const valueSchema = process(def.valueType, ctx, {\n ...params,\n path: [...params.path, \"patternProperties\", \"*\"]\n });\n json2.patternProperties = {};\n for (const pattern of patterns) {\n json2.patternProperties[pattern.source] = valueSchema;\n }\n } else {\n if (ctx.target === \"draft-07\" || ctx.target === \"draft-2020-12\") {\n json2.propertyNames = process(def.keyType, ctx, {\n ...params,\n path: [...params.path, \"propertyNames\"]\n });\n }\n json2.additionalProperties = process(def.valueType, ctx, {\n ...params,\n path: [...params.path, \"additionalProperties\"]\n });\n }\n const keyValues = keyType._zod.values;\n if (keyValues) {\n const validKeyValues = [...keyValues].filter((v) => typeof v === \"string\" || typeof v === \"number\");\n if (validKeyValues.length > 0) {\n json2.required = validKeyValues;\n }\n }\n };\n var nullableProcessor = (schema, ctx, json2, params) => {\n const def = schema._zod.def;\n const inner = process(def.innerType, ctx, params);\n const seen = ctx.seen.get(schema);\n if (ctx.target === \"openapi-3.0\") {\n seen.ref = def.innerType;\n json2.nullable = true;\n } else {\n json2.anyOf = [inner, { type: \"null\" }];\n }\n };\n var nonoptionalProcessor = (schema, ctx, _json, params) => {\n const def = schema._zod.def;\n process(def.innerType, ctx, params);\n const seen = ctx.seen.get(schema);\n seen.ref = def.innerType;\n };\n var defaultProcessor = (schema, ctx, json2, params) => {\n const def = schema._zod.def;\n process(def.innerType, ctx, params);\n const seen = ctx.seen.get(schema);\n seen.ref = def.innerType;\n json2.default = JSON.parse(JSON.stringify(def.defaultValue));\n };\n var prefaultProcessor = (schema, ctx, json2, params) => {\n const def = schema._zod.def;\n process(def.innerType, ctx, params);\n const seen = ctx.seen.get(schema);\n seen.ref = def.innerType;\n if (ctx.io === \"input\")\n json2._prefault = JSON.parse(JSON.stringify(def.defaultValue));\n };\n var catchProcessor = (schema, ctx, json2, params) => {\n const def = schema._zod.def;\n process(def.innerType, ctx, params);\n const seen = ctx.seen.get(schema);\n seen.ref = def.innerType;\n let catchValue;\n try {\n catchValue = def.catchValue(void 0);\n } catch {\n throw new Error(\"Dynamic catch values are not supported in JSON Schema\");\n }\n json2.default = catchValue;\n };\n var pipeProcessor = (schema, ctx, _json, params) => {\n const def = schema._zod.def;\n const innerType = ctx.io === \"input\" ? def.in._zod.def.type === \"transform\" ? def.out : def.in : def.out;\n process(innerType, ctx, params);\n const seen = ctx.seen.get(schema);\n seen.ref = innerType;\n };\n var readonlyProcessor = (schema, ctx, json2, params) => {\n const def = schema._zod.def;\n process(def.innerType, ctx, params);\n const seen = ctx.seen.get(schema);\n seen.ref = def.innerType;\n json2.readOnly = true;\n };\n var promiseProcessor = (schema, ctx, _json, params) => {\n const def = schema._zod.def;\n process(def.innerType, ctx, params);\n const seen = ctx.seen.get(schema);\n seen.ref = def.innerType;\n };\n var optionalProcessor = (schema, ctx, _json, params) => {\n const def = schema._zod.def;\n process(def.innerType, ctx, params);\n const seen = ctx.seen.get(schema);\n seen.ref = def.innerType;\n };\n var lazyProcessor = (schema, ctx, _json, params) => {\n const innerType = schema._zod.innerType;\n process(innerType, ctx, params);\n const seen = ctx.seen.get(schema);\n seen.ref = innerType;\n };\n var allProcessors = {\n string: stringProcessor,\n number: numberProcessor,\n boolean: booleanProcessor,\n bigint: bigintProcessor,\n symbol: symbolProcessor,\n null: nullProcessor,\n undefined: undefinedProcessor,\n void: voidProcessor,\n never: neverProcessor,\n any: anyProcessor,\n unknown: unknownProcessor,\n date: dateProcessor,\n enum: enumProcessor,\n literal: literalProcessor,\n nan: nanProcessor,\n template_literal: templateLiteralProcessor,\n file: fileProcessor,\n success: successProcessor,\n custom: customProcessor,\n function: functionProcessor,\n transform: transformProcessor,\n map: mapProcessor,\n set: setProcessor,\n array: arrayProcessor,\n object: objectProcessor,\n union: unionProcessor,\n intersection: intersectionProcessor,\n tuple: tupleProcessor,\n record: recordProcessor,\n nullable: nullableProcessor,\n nonoptional: nonoptionalProcessor,\n default: defaultProcessor,\n prefault: prefaultProcessor,\n catch: catchProcessor,\n pipe: pipeProcessor,\n readonly: readonlyProcessor,\n promise: promiseProcessor,\n optional: optionalProcessor,\n lazy: lazyProcessor\n };\n function toJSONSchema(input, params) {\n if (\"_idmap\" in input) {\n const registry2 = input;\n const ctx2 = initializeContext({ ...params, processors: allProcessors });\n const defs = {};\n for (const entry of registry2._idmap.entries()) {\n const [_, schema] = entry;\n process(schema, ctx2);\n }\n const schemas = {};\n const external = {\n registry: registry2,\n uri: params?.uri,\n defs\n };\n ctx2.external = external;\n for (const entry of registry2._idmap.entries()) {\n const [key, schema] = entry;\n extractDefs(ctx2, schema);\n schemas[key] = finalize(ctx2, schema);\n }\n if (Object.keys(defs).length > 0) {\n const defsSegment = ctx2.target === \"draft-2020-12\" ? \"$defs\" : \"definitions\";\n schemas.__shared = {\n [defsSegment]: defs\n };\n }\n return { schemas };\n }\n const ctx = initializeContext({ ...params, processors: allProcessors });\n process(input, ctx);\n extractDefs(ctx, input);\n return finalize(ctx, input);\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/json-schema-generator.js\n var JSONSchemaGenerator = class {\n /** @deprecated Access via ctx instead */\n get metadataRegistry() {\n return this.ctx.metadataRegistry;\n }\n /** @deprecated Access via ctx instead */\n get target() {\n return this.ctx.target;\n }\n /** @deprecated Access via ctx instead */\n get unrepresentable() {\n return this.ctx.unrepresentable;\n }\n /** @deprecated Access via ctx instead */\n get override() {\n return this.ctx.override;\n }\n /** @deprecated Access via ctx instead */\n get io() {\n return this.ctx.io;\n }\n /** @deprecated Access via ctx instead */\n get counter() {\n return this.ctx.counter;\n }\n set counter(value) {\n this.ctx.counter = value;\n }\n /** @deprecated Access via ctx instead */\n get seen() {\n return this.ctx.seen;\n }\n constructor(params) {\n let normalizedTarget = params?.target ?? \"draft-2020-12\";\n if (normalizedTarget === \"draft-4\")\n normalizedTarget = \"draft-04\";\n if (normalizedTarget === \"draft-7\")\n normalizedTarget = \"draft-07\";\n this.ctx = initializeContext({\n processors: allProcessors,\n target: normalizedTarget,\n ...params?.metadata && { metadata: params.metadata },\n ...params?.unrepresentable && { unrepresentable: params.unrepresentable },\n ...params?.override && { override: params.override },\n ...params?.io && { io: params.io }\n });\n }\n /**\n * Process a schema to prepare it for JSON Schema generation.\n * This must be called before emit().\n */\n process(schema, _params = { path: [], schemaPath: [] }) {\n return process(schema, this.ctx, _params);\n }\n /**\n * Emit the final JSON Schema after processing.\n * Must call process() first.\n */\n emit(schema, _params) {\n if (_params) {\n if (_params.cycles)\n this.ctx.cycles = _params.cycles;\n if (_params.reused)\n this.ctx.reused = _params.reused;\n if (_params.external)\n this.ctx.external = _params.external;\n }\n extractDefs(this.ctx, schema);\n const result = finalize(this.ctx, schema);\n const { \"~standard\": _, ...plainResult } = result;\n return plainResult;\n }\n };\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/json-schema.js\n var json_schema_exports = {};\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/schemas.js\n var schemas_exports2 = {};\n __export(schemas_exports2, {\n ZodAny: () => ZodAny,\n ZodArray: () => ZodArray,\n ZodBase64: () => ZodBase64,\n ZodBase64URL: () => ZodBase64URL,\n ZodBigInt: () => ZodBigInt,\n ZodBigIntFormat: () => ZodBigIntFormat,\n ZodBoolean: () => ZodBoolean,\n ZodCIDRv4: () => ZodCIDRv4,\n ZodCIDRv6: () => ZodCIDRv6,\n ZodCUID: () => ZodCUID,\n ZodCUID2: () => ZodCUID2,\n ZodCatch: () => ZodCatch,\n ZodCodec: () => ZodCodec,\n ZodCustom: () => ZodCustom,\n ZodCustomStringFormat: () => ZodCustomStringFormat,\n ZodDate: () => ZodDate,\n ZodDefault: () => ZodDefault,\n ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,\n ZodE164: () => ZodE164,\n ZodEmail: () => ZodEmail,\n ZodEmoji: () => ZodEmoji,\n ZodEnum: () => ZodEnum,\n ZodExactOptional: () => ZodExactOptional,\n ZodFile: () => ZodFile,\n ZodFunction: () => ZodFunction,\n ZodGUID: () => ZodGUID,\n ZodIPv4: () => ZodIPv4,\n ZodIPv6: () => ZodIPv6,\n ZodIntersection: () => ZodIntersection,\n ZodJWT: () => ZodJWT,\n ZodKSUID: () => ZodKSUID,\n ZodLazy: () => ZodLazy,\n ZodLiteral: () => ZodLiteral,\n ZodMAC: () => ZodMAC,\n ZodMap: () => ZodMap,\n ZodNaN: () => ZodNaN,\n ZodNanoID: () => ZodNanoID,\n ZodNever: () => ZodNever,\n ZodNonOptional: () => ZodNonOptional,\n ZodNull: () => ZodNull,\n ZodNullable: () => ZodNullable,\n ZodNumber: () => ZodNumber,\n ZodNumberFormat: () => ZodNumberFormat,\n ZodObject: () => ZodObject,\n ZodOptional: () => ZodOptional,\n ZodPipe: () => ZodPipe,\n ZodPrefault: () => ZodPrefault,\n ZodPromise: () => ZodPromise,\n ZodReadonly: () => ZodReadonly,\n ZodRecord: () => ZodRecord,\n ZodSet: () => ZodSet,\n ZodString: () => ZodString,\n ZodStringFormat: () => ZodStringFormat,\n ZodSuccess: () => ZodSuccess,\n ZodSymbol: () => ZodSymbol,\n ZodTemplateLiteral: () => ZodTemplateLiteral,\n ZodTransform: () => ZodTransform,\n ZodTuple: () => ZodTuple,\n ZodType: () => ZodType,\n ZodULID: () => ZodULID,\n ZodURL: () => ZodURL,\n ZodUUID: () => ZodUUID,\n ZodUndefined: () => ZodUndefined,\n ZodUnion: () => ZodUnion,\n ZodUnknown: () => ZodUnknown,\n ZodVoid: () => ZodVoid,\n ZodXID: () => ZodXID,\n ZodXor: () => ZodXor,\n _ZodString: () => _ZodString,\n _default: () => _default2,\n _function: () => _function,\n any: () => any,\n array: () => array,\n base64: () => base642,\n base64url: () => base64url2,\n bigint: () => bigint2,\n boolean: () => boolean2,\n catch: () => _catch2,\n check: () => check,\n cidrv4: () => cidrv42,\n cidrv6: () => cidrv62,\n codec: () => codec,\n cuid: () => cuid3,\n cuid2: () => cuid22,\n custom: () => custom,\n date: () => date3,\n describe: () => describe2,\n discriminatedUnion: () => discriminatedUnion,\n e164: () => e1642,\n email: () => email2,\n emoji: () => emoji2,\n enum: () => _enum2,\n exactOptional: () => exactOptional,\n file: () => file,\n float32: () => float32,\n float64: () => float64,\n function: () => _function,\n guid: () => guid2,\n hash: () => hash,\n hex: () => hex2,\n hostname: () => hostname2,\n httpUrl: () => httpUrl,\n instanceof: () => _instanceof,\n int: () => int,\n int32: () => int32,\n int64: () => int64,\n intersection: () => intersection,\n ipv4: () => ipv42,\n ipv6: () => ipv62,\n json: () => json,\n jwt: () => jwt,\n keyof: () => keyof,\n ksuid: () => ksuid2,\n lazy: () => lazy,\n literal: () => literal,\n looseObject: () => looseObject,\n looseRecord: () => looseRecord,\n mac: () => mac2,\n map: () => map,\n meta: () => meta2,\n nan: () => nan,\n nanoid: () => nanoid2,\n nativeEnum: () => nativeEnum,\n never: () => never,\n nonoptional: () => nonoptional,\n null: () => _null3,\n nullable: () => nullable,\n nullish: () => nullish2,\n number: () => number2,\n object: () => object,\n optional: () => optional,\n partialRecord: () => partialRecord,\n pipe: () => pipe,\n prefault: () => prefault,\n preprocess: () => preprocess,\n promise: () => promise,\n readonly: () => readonly,\n record: () => record,\n refine: () => refine,\n set: () => set,\n strictObject: () => strictObject,\n string: () => string2,\n stringFormat: () => stringFormat,\n stringbool: () => stringbool,\n success: () => success,\n superRefine: () => superRefine,\n symbol: () => symbol,\n templateLiteral: () => templateLiteral,\n transform: () => transform,\n tuple: () => tuple,\n uint32: () => uint32,\n uint64: () => uint64,\n ulid: () => ulid2,\n undefined: () => _undefined3,\n union: () => union,\n unknown: () => unknown,\n url: () => url,\n uuid: () => uuid2,\n uuidv4: () => uuidv4,\n uuidv6: () => uuidv6,\n uuidv7: () => uuidv7,\n void: () => _void2,\n xid: () => xid2,\n xor: () => xor\n });\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/checks.js\n var checks_exports2 = {};\n __export(checks_exports2, {\n endsWith: () => _endsWith,\n gt: () => _gt,\n gte: () => _gte,\n includes: () => _includes,\n length: () => _length,\n lowercase: () => _lowercase,\n lt: () => _lt,\n lte: () => _lte,\n maxLength: () => _maxLength,\n maxSize: () => _maxSize,\n mime: () => _mime,\n minLength: () => _minLength,\n minSize: () => _minSize,\n multipleOf: () => _multipleOf,\n negative: () => _negative,\n nonnegative: () => _nonnegative,\n nonpositive: () => _nonpositive,\n normalize: () => _normalize,\n overwrite: () => _overwrite,\n positive: () => _positive,\n property: () => _property,\n regex: () => _regex,\n size: () => _size,\n slugify: () => _slugify,\n startsWith: () => _startsWith,\n toLowerCase: () => _toLowerCase,\n toUpperCase: () => _toUpperCase,\n trim: () => _trim,\n uppercase: () => _uppercase\n });\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/iso.js\n var iso_exports = {};\n __export(iso_exports, {\n ZodISODate: () => ZodISODate,\n ZodISODateTime: () => ZodISODateTime,\n ZodISODuration: () => ZodISODuration,\n ZodISOTime: () => ZodISOTime,\n date: () => date2,\n datetime: () => datetime2,\n duration: () => duration2,\n time: () => time2\n });\n var ZodISODateTime = /* @__PURE__ */ $constructor(\"ZodISODateTime\", (inst, def) => {\n $ZodISODateTime.init(inst, def);\n ZodStringFormat.init(inst, def);\n });\n function datetime2(params) {\n return _isoDateTime(ZodISODateTime, params);\n }\n var ZodISODate = /* @__PURE__ */ $constructor(\"ZodISODate\", (inst, def) => {\n $ZodISODate.init(inst, def);\n ZodStringFormat.init(inst, def);\n });\n function date2(params) {\n return _isoDate(ZodISODate, params);\n }\n var ZodISOTime = /* @__PURE__ */ $constructor(\"ZodISOTime\", (inst, def) => {\n $ZodISOTime.init(inst, def);\n ZodStringFormat.init(inst, def);\n });\n function time2(params) {\n return _isoTime(ZodISOTime, params);\n }\n var ZodISODuration = /* @__PURE__ */ $constructor(\"ZodISODuration\", (inst, def) => {\n $ZodISODuration.init(inst, def);\n ZodStringFormat.init(inst, def);\n });\n function duration2(params) {\n return _isoDuration(ZodISODuration, params);\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/errors.js\n var initializer2 = (inst, issues) => {\n $ZodError.init(inst, issues);\n inst.name = \"ZodError\";\n Object.defineProperties(inst, {\n format: {\n value: (mapper) => formatError(inst, mapper)\n // enumerable: false,\n },\n flatten: {\n value: (mapper) => flattenError(inst, mapper)\n // enumerable: false,\n },\n addIssue: {\n value: (issue2) => {\n inst.issues.push(issue2);\n inst.message = JSON.stringify(inst.issues, jsonStringifyReplacer, 2);\n }\n // enumerable: false,\n },\n addIssues: {\n value: (issues2) => {\n inst.issues.push(...issues2);\n inst.message = JSON.stringify(inst.issues, jsonStringifyReplacer, 2);\n }\n // enumerable: false,\n },\n isEmpty: {\n get() {\n return inst.issues.length === 0;\n }\n // enumerable: false,\n }\n });\n };\n var ZodError = $constructor(\"ZodError\", initializer2);\n var ZodRealError = $constructor(\"ZodError\", initializer2, {\n Parent: Error\n });\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/parse.js\n var parse2 = /* @__PURE__ */ _parse(ZodRealError);\n var parseAsync2 = /* @__PURE__ */ _parseAsync(ZodRealError);\n var safeParse2 = /* @__PURE__ */ _safeParse(ZodRealError);\n var safeParseAsync2 = /* @__PURE__ */ _safeParseAsync(ZodRealError);\n var encode2 = /* @__PURE__ */ _encode(ZodRealError);\n var decode2 = /* @__PURE__ */ _decode(ZodRealError);\n var encodeAsync2 = /* @__PURE__ */ _encodeAsync(ZodRealError);\n var decodeAsync2 = /* @__PURE__ */ _decodeAsync(ZodRealError);\n var safeEncode2 = /* @__PURE__ */ _safeEncode(ZodRealError);\n var safeDecode2 = /* @__PURE__ */ _safeDecode(ZodRealError);\n var safeEncodeAsync2 = /* @__PURE__ */ _safeEncodeAsync(ZodRealError);\n var safeDecodeAsync2 = /* @__PURE__ */ _safeDecodeAsync(ZodRealError);\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/schemas.js\n var ZodType = /* @__PURE__ */ $constructor(\"ZodType\", (inst, def) => {\n $ZodType.init(inst, def);\n Object.assign(inst[\"~standard\"], {\n jsonSchema: {\n input: createStandardJSONSchemaMethod(inst, \"input\"),\n output: createStandardJSONSchemaMethod(inst, \"output\")\n }\n });\n inst.toJSONSchema = createToJSONSchemaMethod(inst, {});\n inst.def = def;\n inst.type = def.type;\n Object.defineProperty(inst, \"_def\", { value: def });\n inst.check = (...checks) => {\n return inst.clone(util_exports.mergeDefs(def, {\n checks: [\n ...def.checks ?? [],\n ...checks.map((ch) => typeof ch === \"function\" ? { _zod: { check: ch, def: { check: \"custom\" }, onattach: [] } } : ch)\n ]\n }), {\n parent: true\n });\n };\n inst.with = inst.check;\n inst.clone = (def2, params) => clone(inst, def2, params);\n inst.brand = () => inst;\n inst.register = ((reg, meta3) => {\n reg.add(inst, meta3);\n return inst;\n });\n inst.parse = (data, params) => parse2(inst, data, params, { callee: inst.parse });\n inst.safeParse = (data, params) => safeParse2(inst, data, params);\n inst.parseAsync = async (data, params) => parseAsync2(inst, data, params, { callee: inst.parseAsync });\n inst.safeParseAsync = async (data, params) => safeParseAsync2(inst, data, params);\n inst.spa = inst.safeParseAsync;\n inst.encode = (data, params) => encode2(inst, data, params);\n inst.decode = (data, params) => decode2(inst, data, params);\n inst.encodeAsync = async (data, params) => encodeAsync2(inst, data, params);\n inst.decodeAsync = async (data, params) => decodeAsync2(inst, data, params);\n inst.safeEncode = (data, params) => safeEncode2(inst, data, params);\n inst.safeDecode = (data, params) => safeDecode2(inst, data, params);\n inst.safeEncodeAsync = async (data, params) => safeEncodeAsync2(inst, data, params);\n inst.safeDecodeAsync = async (data, params) => safeDecodeAsync2(inst, data, params);\n inst.refine = (check2, params) => inst.check(refine(check2, params));\n inst.superRefine = (refinement) => inst.check(superRefine(refinement));\n inst.overwrite = (fn) => inst.check(_overwrite(fn));\n inst.optional = () => optional(inst);\n inst.exactOptional = () => exactOptional(inst);\n inst.nullable = () => nullable(inst);\n inst.nullish = () => optional(nullable(inst));\n inst.nonoptional = (params) => nonoptional(inst, params);\n inst.array = () => array(inst);\n inst.or = (arg) => union([inst, arg]);\n inst.and = (arg) => intersection(inst, arg);\n inst.transform = (tx) => pipe(inst, transform(tx));\n inst.default = (def2) => _default2(inst, def2);\n inst.prefault = (def2) => prefault(inst, def2);\n inst.catch = (params) => _catch2(inst, params);\n inst.pipe = (target) => pipe(inst, target);\n inst.readonly = () => readonly(inst);\n inst.describe = (description) => {\n const cl = inst.clone();\n globalRegistry.add(cl, { description });\n return cl;\n };\n Object.defineProperty(inst, \"description\", {\n get() {\n return globalRegistry.get(inst)?.description;\n },\n configurable: true\n });\n inst.meta = (...args) => {\n if (args.length === 0) {\n return globalRegistry.get(inst);\n }\n const cl = inst.clone();\n globalRegistry.add(cl, args[0]);\n return cl;\n };\n inst.isOptional = () => inst.safeParse(void 0).success;\n inst.isNullable = () => inst.safeParse(null).success;\n inst.apply = (fn) => fn(inst);\n return inst;\n });\n var _ZodString = /* @__PURE__ */ $constructor(\"_ZodString\", (inst, def) => {\n $ZodString.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json2, params) => stringProcessor(inst, ctx, json2, params);\n const bag = inst._zod.bag;\n inst.format = bag.format ?? null;\n inst.minLength = bag.minimum ?? null;\n inst.maxLength = bag.maximum ?? null;\n inst.regex = (...args) => inst.check(_regex(...args));\n inst.includes = (...args) => inst.check(_includes(...args));\n inst.startsWith = (...args) => inst.check(_startsWith(...args));\n inst.endsWith = (...args) => inst.check(_endsWith(...args));\n inst.min = (...args) => inst.check(_minLength(...args));\n inst.max = (...args) => inst.check(_maxLength(...args));\n inst.length = (...args) => inst.check(_length(...args));\n inst.nonempty = (...args) => inst.check(_minLength(1, ...args));\n inst.lowercase = (params) => inst.check(_lowercase(params));\n inst.uppercase = (params) => inst.check(_uppercase(params));\n inst.trim = () => inst.check(_trim());\n inst.normalize = (...args) => inst.check(_normalize(...args));\n inst.toLowerCase = () => inst.check(_toLowerCase());\n inst.toUpperCase = () => inst.check(_toUpperCase());\n inst.slugify = () => inst.check(_slugify());\n });\n var ZodString = /* @__PURE__ */ $constructor(\"ZodString\", (inst, def) => {\n $ZodString.init(inst, def);\n _ZodString.init(inst, def);\n inst.email = (params) => inst.check(_email(ZodEmail, params));\n inst.url = (params) => inst.check(_url(ZodURL, params));\n inst.jwt = (params) => inst.check(_jwt(ZodJWT, params));\n inst.emoji = (params) => inst.check(_emoji2(ZodEmoji, params));\n inst.guid = (params) => inst.check(_guid(ZodGUID, params));\n inst.uuid = (params) => inst.check(_uuid(ZodUUID, params));\n inst.uuidv4 = (params) => inst.check(_uuidv4(ZodUUID, params));\n inst.uuidv6 = (params) => inst.check(_uuidv6(ZodUUID, params));\n inst.uuidv7 = (params) => inst.check(_uuidv7(ZodUUID, params));\n inst.nanoid = (params) => inst.check(_nanoid(ZodNanoID, params));\n inst.guid = (params) => inst.check(_guid(ZodGUID, params));\n inst.cuid = (params) => inst.check(_cuid(ZodCUID, params));\n inst.cuid2 = (params) => inst.check(_cuid2(ZodCUID2, params));\n inst.ulid = (params) => inst.check(_ulid(ZodULID, params));\n inst.base64 = (params) => inst.check(_base64(ZodBase64, params));\n inst.base64url = (params) => inst.check(_base64url(ZodBase64URL, params));\n inst.xid = (params) => inst.check(_xid(ZodXID, params));\n inst.ksuid = (params) => inst.check(_ksuid(ZodKSUID, params));\n inst.ipv4 = (params) => inst.check(_ipv4(ZodIPv4, params));\n inst.ipv6 = (params) => inst.check(_ipv6(ZodIPv6, params));\n inst.cidrv4 = (params) => inst.check(_cidrv4(ZodCIDRv4, params));\n inst.cidrv6 = (params) => inst.check(_cidrv6(ZodCIDRv6, params));\n inst.e164 = (params) => inst.check(_e164(ZodE164, params));\n inst.datetime = (params) => inst.check(datetime2(params));\n inst.date = (params) => inst.check(date2(params));\n inst.time = (params) => inst.check(time2(params));\n inst.duration = (params) => inst.check(duration2(params));\n });\n function string2(params) {\n return _string(ZodString, params);\n }\n var ZodStringFormat = /* @__PURE__ */ $constructor(\"ZodStringFormat\", (inst, def) => {\n $ZodStringFormat.init(inst, def);\n _ZodString.init(inst, def);\n });\n var ZodEmail = /* @__PURE__ */ $constructor(\"ZodEmail\", (inst, def) => {\n $ZodEmail.init(inst, def);\n ZodStringFormat.init(inst, def);\n });\n function email2(params) {\n return _email(ZodEmail, params);\n }\n var ZodGUID = /* @__PURE__ */ $constructor(\"ZodGUID\", (inst, def) => {\n $ZodGUID.init(inst, def);\n ZodStringFormat.init(inst, def);\n });\n function guid2(params) {\n return _guid(ZodGUID, params);\n }\n var ZodUUID = /* @__PURE__ */ $constructor(\"ZodUUID\", (inst, def) => {\n $ZodUUID.init(inst, def);\n ZodStringFormat.init(inst, def);\n });\n function uuid2(params) {\n return _uuid(ZodUUID, params);\n }\n function uuidv4(params) {\n return _uuidv4(ZodUUID, params);\n }\n function uuidv6(params) {\n return _uuidv6(ZodUUID, params);\n }\n function uuidv7(params) {\n return _uuidv7(ZodUUID, params);\n }\n var ZodURL = /* @__PURE__ */ $constructor(\"ZodURL\", (inst, def) => {\n $ZodURL.init(inst, def);\n ZodStringFormat.init(inst, def);\n });\n function url(params) {\n return _url(ZodURL, params);\n }\n function httpUrl(params) {\n return _url(ZodURL, {\n protocol: /^https?$/,\n hostname: regexes_exports.domain,\n ...util_exports.normalizeParams(params)\n });\n }\n var ZodEmoji = /* @__PURE__ */ $constructor(\"ZodEmoji\", (inst, def) => {\n $ZodEmoji.init(inst, def);\n ZodStringFormat.init(inst, def);\n });\n function emoji2(params) {\n return _emoji2(ZodEmoji, params);\n }\n var ZodNanoID = /* @__PURE__ */ $constructor(\"ZodNanoID\", (inst, def) => {\n $ZodNanoID.init(inst, def);\n ZodStringFormat.init(inst, def);\n });\n function nanoid2(params) {\n return _nanoid(ZodNanoID, params);\n }\n var ZodCUID = /* @__PURE__ */ $constructor(\"ZodCUID\", (inst, def) => {\n $ZodCUID.init(inst, def);\n ZodStringFormat.init(inst, def);\n });\n function cuid3(params) {\n return _cuid(ZodCUID, params);\n }\n var ZodCUID2 = /* @__PURE__ */ $constructor(\"ZodCUID2\", (inst, def) => {\n $ZodCUID2.init(inst, def);\n ZodStringFormat.init(inst, def);\n });\n function cuid22(params) {\n return _cuid2(ZodCUID2, params);\n }\n var ZodULID = /* @__PURE__ */ $constructor(\"ZodULID\", (inst, def) => {\n $ZodULID.init(inst, def);\n ZodStringFormat.init(inst, def);\n });\n function ulid2(params) {\n return _ulid(ZodULID, params);\n }\n var ZodXID = /* @__PURE__ */ $constructor(\"ZodXID\", (inst, def) => {\n $ZodXID.init(inst, def);\n ZodStringFormat.init(inst, def);\n });\n function xid2(params) {\n return _xid(ZodXID, params);\n }\n var ZodKSUID = /* @__PURE__ */ $constructor(\"ZodKSUID\", (inst, def) => {\n $ZodKSUID.init(inst, def);\n ZodStringFormat.init(inst, def);\n });\n function ksuid2(params) {\n return _ksuid(ZodKSUID, params);\n }\n var ZodIPv4 = /* @__PURE__ */ $constructor(\"ZodIPv4\", (inst, def) => {\n $ZodIPv4.init(inst, def);\n ZodStringFormat.init(inst, def);\n });\n function ipv42(params) {\n return _ipv4(ZodIPv4, params);\n }\n var ZodMAC = /* @__PURE__ */ $constructor(\"ZodMAC\", (inst, def) => {\n $ZodMAC.init(inst, def);\n ZodStringFormat.init(inst, def);\n });\n function mac2(params) {\n return _mac(ZodMAC, params);\n }\n var ZodIPv6 = /* @__PURE__ */ $constructor(\"ZodIPv6\", (inst, def) => {\n $ZodIPv6.init(inst, def);\n ZodStringFormat.init(inst, def);\n });\n function ipv62(params) {\n return _ipv6(ZodIPv6, params);\n }\n var ZodCIDRv4 = /* @__PURE__ */ $constructor(\"ZodCIDRv4\", (inst, def) => {\n $ZodCIDRv4.init(inst, def);\n ZodStringFormat.init(inst, def);\n });\n function cidrv42(params) {\n return _cidrv4(ZodCIDRv4, params);\n }\n var ZodCIDRv6 = /* @__PURE__ */ $constructor(\"ZodCIDRv6\", (inst, def) => {\n $ZodCIDRv6.init(inst, def);\n ZodStringFormat.init(inst, def);\n });\n function cidrv62(params) {\n return _cidrv6(ZodCIDRv6, params);\n }\n var ZodBase64 = /* @__PURE__ */ $constructor(\"ZodBase64\", (inst, def) => {\n $ZodBase64.init(inst, def);\n ZodStringFormat.init(inst, def);\n });\n function base642(params) {\n return _base64(ZodBase64, params);\n }\n var ZodBase64URL = /* @__PURE__ */ $constructor(\"ZodBase64URL\", (inst, def) => {\n $ZodBase64URL.init(inst, def);\n ZodStringFormat.init(inst, def);\n });\n function base64url2(params) {\n return _base64url(ZodBase64URL, params);\n }\n var ZodE164 = /* @__PURE__ */ $constructor(\"ZodE164\", (inst, def) => {\n $ZodE164.init(inst, def);\n ZodStringFormat.init(inst, def);\n });\n function e1642(params) {\n return _e164(ZodE164, params);\n }\n var ZodJWT = /* @__PURE__ */ $constructor(\"ZodJWT\", (inst, def) => {\n $ZodJWT.init(inst, def);\n ZodStringFormat.init(inst, def);\n });\n function jwt(params) {\n return _jwt(ZodJWT, params);\n }\n var ZodCustomStringFormat = /* @__PURE__ */ $constructor(\"ZodCustomStringFormat\", (inst, def) => {\n $ZodCustomStringFormat.init(inst, def);\n ZodStringFormat.init(inst, def);\n });\n function stringFormat(format, fnOrRegex, _params = {}) {\n return _stringFormat(ZodCustomStringFormat, format, fnOrRegex, _params);\n }\n function hostname2(_params) {\n return _stringFormat(ZodCustomStringFormat, \"hostname\", regexes_exports.hostname, _params);\n }\n function hex2(_params) {\n return _stringFormat(ZodCustomStringFormat, \"hex\", regexes_exports.hex, _params);\n }\n function hash(alg, params) {\n const enc = params?.enc ?? \"hex\";\n const format = `${alg}_${enc}`;\n const regex = regexes_exports[format];\n if (!regex)\n throw new Error(`Unrecognized hash format: ${format}`);\n return _stringFormat(ZodCustomStringFormat, format, regex, params);\n }\n var ZodNumber = /* @__PURE__ */ $constructor(\"ZodNumber\", (inst, def) => {\n $ZodNumber.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json2, params) => numberProcessor(inst, ctx, json2, params);\n inst.gt = (value, params) => inst.check(_gt(value, params));\n inst.gte = (value, params) => inst.check(_gte(value, params));\n inst.min = (value, params) => inst.check(_gte(value, params));\n inst.lt = (value, params) => inst.check(_lt(value, params));\n inst.lte = (value, params) => inst.check(_lte(value, params));\n inst.max = (value, params) => inst.check(_lte(value, params));\n inst.int = (params) => inst.check(int(params));\n inst.safe = (params) => inst.check(int(params));\n inst.positive = (params) => inst.check(_gt(0, params));\n inst.nonnegative = (params) => inst.check(_gte(0, params));\n inst.negative = (params) => inst.check(_lt(0, params));\n inst.nonpositive = (params) => inst.check(_lte(0, params));\n inst.multipleOf = (value, params) => inst.check(_multipleOf(value, params));\n inst.step = (value, params) => inst.check(_multipleOf(value, params));\n inst.finite = () => inst;\n const bag = inst._zod.bag;\n inst.minValue = Math.max(bag.minimum ?? Number.NEGATIVE_INFINITY, bag.exclusiveMinimum ?? Number.NEGATIVE_INFINITY) ?? null;\n inst.maxValue = Math.min(bag.maximum ?? Number.POSITIVE_INFINITY, bag.exclusiveMaximum ?? Number.POSITIVE_INFINITY) ?? null;\n inst.isInt = (bag.format ?? \"\").includes(\"int\") || Number.isSafeInteger(bag.multipleOf ?? 0.5);\n inst.isFinite = true;\n inst.format = bag.format ?? null;\n });\n function number2(params) {\n return _number(ZodNumber, params);\n }\n var ZodNumberFormat = /* @__PURE__ */ $constructor(\"ZodNumberFormat\", (inst, def) => {\n $ZodNumberFormat.init(inst, def);\n ZodNumber.init(inst, def);\n });\n function int(params) {\n return _int(ZodNumberFormat, params);\n }\n function float32(params) {\n return _float32(ZodNumberFormat, params);\n }\n function float64(params) {\n return _float64(ZodNumberFormat, params);\n }\n function int32(params) {\n return _int32(ZodNumberFormat, params);\n }\n function uint32(params) {\n return _uint32(ZodNumberFormat, params);\n }\n var ZodBoolean = /* @__PURE__ */ $constructor(\"ZodBoolean\", (inst, def) => {\n $ZodBoolean.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json2, params) => booleanProcessor(inst, ctx, json2, params);\n });\n function boolean2(params) {\n return _boolean(ZodBoolean, params);\n }\n var ZodBigInt = /* @__PURE__ */ $constructor(\"ZodBigInt\", (inst, def) => {\n $ZodBigInt.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json2, params) => bigintProcessor(inst, ctx, json2, params);\n inst.gte = (value, params) => inst.check(_gte(value, params));\n inst.min = (value, params) => inst.check(_gte(value, params));\n inst.gt = (value, params) => inst.check(_gt(value, params));\n inst.gte = (value, params) => inst.check(_gte(value, params));\n inst.min = (value, params) => inst.check(_gte(value, params));\n inst.lt = (value, params) => inst.check(_lt(value, params));\n inst.lte = (value, params) => inst.check(_lte(value, params));\n inst.max = (value, params) => inst.check(_lte(value, params));\n inst.positive = (params) => inst.check(_gt(BigInt(0), params));\n inst.negative = (params) => inst.check(_lt(BigInt(0), params));\n inst.nonpositive = (params) => inst.check(_lte(BigInt(0), params));\n inst.nonnegative = (params) => inst.check(_gte(BigInt(0), params));\n inst.multipleOf = (value, params) => inst.check(_multipleOf(value, params));\n const bag = inst._zod.bag;\n inst.minValue = bag.minimum ?? null;\n inst.maxValue = bag.maximum ?? null;\n inst.format = bag.format ?? null;\n });\n function bigint2(params) {\n return _bigint(ZodBigInt, params);\n }\n var ZodBigIntFormat = /* @__PURE__ */ $constructor(\"ZodBigIntFormat\", (inst, def) => {\n $ZodBigIntFormat.init(inst, def);\n ZodBigInt.init(inst, def);\n });\n function int64(params) {\n return _int64(ZodBigIntFormat, params);\n }\n function uint64(params) {\n return _uint64(ZodBigIntFormat, params);\n }\n var ZodSymbol = /* @__PURE__ */ $constructor(\"ZodSymbol\", (inst, def) => {\n $ZodSymbol.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json2, params) => symbolProcessor(inst, ctx, json2, params);\n });\n function symbol(params) {\n return _symbol(ZodSymbol, params);\n }\n var ZodUndefined = /* @__PURE__ */ $constructor(\"ZodUndefined\", (inst, def) => {\n $ZodUndefined.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json2, params) => undefinedProcessor(inst, ctx, json2, params);\n });\n function _undefined3(params) {\n return _undefined2(ZodUndefined, params);\n }\n var ZodNull = /* @__PURE__ */ $constructor(\"ZodNull\", (inst, def) => {\n $ZodNull.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json2, params) => nullProcessor(inst, ctx, json2, params);\n });\n function _null3(params) {\n return _null2(ZodNull, params);\n }\n var ZodAny = /* @__PURE__ */ $constructor(\"ZodAny\", (inst, def) => {\n $ZodAny.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json2, params) => anyProcessor(inst, ctx, json2, params);\n });\n function any() {\n return _any(ZodAny);\n }\n var ZodUnknown = /* @__PURE__ */ $constructor(\"ZodUnknown\", (inst, def) => {\n $ZodUnknown.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json2, params) => unknownProcessor(inst, ctx, json2, params);\n });\n function unknown() {\n return _unknown(ZodUnknown);\n }\n var ZodNever = /* @__PURE__ */ $constructor(\"ZodNever\", (inst, def) => {\n $ZodNever.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json2, params) => neverProcessor(inst, ctx, json2, params);\n });\n function never(params) {\n return _never(ZodNever, params);\n }\n var ZodVoid = /* @__PURE__ */ $constructor(\"ZodVoid\", (inst, def) => {\n $ZodVoid.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json2, params) => voidProcessor(inst, ctx, json2, params);\n });\n function _void2(params) {\n return _void(ZodVoid, params);\n }\n var ZodDate = /* @__PURE__ */ $constructor(\"ZodDate\", (inst, def) => {\n $ZodDate.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json2, params) => dateProcessor(inst, ctx, json2, params);\n inst.min = (value, params) => inst.check(_gte(value, params));\n inst.max = (value, params) => inst.check(_lte(value, params));\n const c = inst._zod.bag;\n inst.minDate = c.minimum ? new Date(c.minimum) : null;\n inst.maxDate = c.maximum ? new Date(c.maximum) : null;\n });\n function date3(params) {\n return _date(ZodDate, params);\n }\n var ZodArray = /* @__PURE__ */ $constructor(\"ZodArray\", (inst, def) => {\n $ZodArray.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json2, params) => arrayProcessor(inst, ctx, json2, params);\n inst.element = def.element;\n inst.min = (minLength, params) => inst.check(_minLength(minLength, params));\n inst.nonempty = (params) => inst.check(_minLength(1, params));\n inst.max = (maxLength, params) => inst.check(_maxLength(maxLength, params));\n inst.length = (len, params) => inst.check(_length(len, params));\n inst.unwrap = () => inst.element;\n });\n function array(element, params) {\n return _array(ZodArray, element, params);\n }\n function keyof(schema) {\n const shape = schema._zod.def.shape;\n return _enum2(Object.keys(shape));\n }\n var ZodObject = /* @__PURE__ */ $constructor(\"ZodObject\", (inst, def) => {\n $ZodObjectJIT.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json2, params) => objectProcessor(inst, ctx, json2, params);\n util_exports.defineLazy(inst, \"shape\", () => {\n return def.shape;\n });\n inst.keyof = () => _enum2(Object.keys(inst._zod.def.shape));\n inst.catchall = (catchall) => inst.clone({ ...inst._zod.def, catchall });\n inst.passthrough = () => inst.clone({ ...inst._zod.def, catchall: unknown() });\n inst.loose = () => inst.clone({ ...inst._zod.def, catchall: unknown() });\n inst.strict = () => inst.clone({ ...inst._zod.def, catchall: never() });\n inst.strip = () => inst.clone({ ...inst._zod.def, catchall: void 0 });\n inst.extend = (incoming) => {\n return util_exports.extend(inst, incoming);\n };\n inst.safeExtend = (incoming) => {\n return util_exports.safeExtend(inst, incoming);\n };\n inst.merge = (other) => util_exports.merge(inst, other);\n inst.pick = (mask) => util_exports.pick(inst, mask);\n inst.omit = (mask) => util_exports.omit(inst, mask);\n inst.partial = (...args) => util_exports.partial(ZodOptional, inst, args[0]);\n inst.required = (...args) => util_exports.required(ZodNonOptional, inst, args[0]);\n });\n function object(shape, params) {\n const def = {\n type: \"object\",\n shape: shape ?? {},\n ...util_exports.normalizeParams(params)\n };\n return new ZodObject(def);\n }\n function strictObject(shape, params) {\n return new ZodObject({\n type: \"object\",\n shape,\n catchall: never(),\n ...util_exports.normalizeParams(params)\n });\n }\n function looseObject(shape, params) {\n return new ZodObject({\n type: \"object\",\n shape,\n catchall: unknown(),\n ...util_exports.normalizeParams(params)\n });\n }\n var ZodUnion = /* @__PURE__ */ $constructor(\"ZodUnion\", (inst, def) => {\n $ZodUnion.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json2, params) => unionProcessor(inst, ctx, json2, params);\n inst.options = def.options;\n });\n function union(options, params) {\n return new ZodUnion({\n type: \"union\",\n options,\n ...util_exports.normalizeParams(params)\n });\n }\n var ZodXor = /* @__PURE__ */ $constructor(\"ZodXor\", (inst, def) => {\n ZodUnion.init(inst, def);\n $ZodXor.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json2, params) => unionProcessor(inst, ctx, json2, params);\n inst.options = def.options;\n });\n function xor(options, params) {\n return new ZodXor({\n type: \"union\",\n options,\n inclusive: false,\n ...util_exports.normalizeParams(params)\n });\n }\n var ZodDiscriminatedUnion = /* @__PURE__ */ $constructor(\"ZodDiscriminatedUnion\", (inst, def) => {\n ZodUnion.init(inst, def);\n $ZodDiscriminatedUnion.init(inst, def);\n });\n function discriminatedUnion(discriminator, options, params) {\n return new ZodDiscriminatedUnion({\n type: \"union\",\n options,\n discriminator,\n ...util_exports.normalizeParams(params)\n });\n }\n var ZodIntersection = /* @__PURE__ */ $constructor(\"ZodIntersection\", (inst, def) => {\n $ZodIntersection.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json2, params) => intersectionProcessor(inst, ctx, json2, params);\n });\n function intersection(left, right) {\n return new ZodIntersection({\n type: \"intersection\",\n left,\n right\n });\n }\n var ZodTuple = /* @__PURE__ */ $constructor(\"ZodTuple\", (inst, def) => {\n $ZodTuple.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json2, params) => tupleProcessor(inst, ctx, json2, params);\n inst.rest = (rest) => inst.clone({\n ...inst._zod.def,\n rest\n });\n });\n function tuple(items, _paramsOrRest, _params) {\n const hasRest = _paramsOrRest instanceof $ZodType;\n const params = hasRest ? _params : _paramsOrRest;\n const rest = hasRest ? _paramsOrRest : null;\n return new ZodTuple({\n type: \"tuple\",\n items,\n rest,\n ...util_exports.normalizeParams(params)\n });\n }\n var ZodRecord = /* @__PURE__ */ $constructor(\"ZodRecord\", (inst, def) => {\n $ZodRecord.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json2, params) => recordProcessor(inst, ctx, json2, params);\n inst.keyType = def.keyType;\n inst.valueType = def.valueType;\n });\n function record(keyType, valueType, params) {\n return new ZodRecord({\n type: \"record\",\n keyType,\n valueType,\n ...util_exports.normalizeParams(params)\n });\n }\n function partialRecord(keyType, valueType, params) {\n const k = clone(keyType);\n k._zod.values = void 0;\n return new ZodRecord({\n type: \"record\",\n keyType: k,\n valueType,\n ...util_exports.normalizeParams(params)\n });\n }\n function looseRecord(keyType, valueType, params) {\n return new ZodRecord({\n type: \"record\",\n keyType,\n valueType,\n mode: \"loose\",\n ...util_exports.normalizeParams(params)\n });\n }\n var ZodMap = /* @__PURE__ */ $constructor(\"ZodMap\", (inst, def) => {\n $ZodMap.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json2, params) => mapProcessor(inst, ctx, json2, params);\n inst.keyType = def.keyType;\n inst.valueType = def.valueType;\n inst.min = (...args) => inst.check(_minSize(...args));\n inst.nonempty = (params) => inst.check(_minSize(1, params));\n inst.max = (...args) => inst.check(_maxSize(...args));\n inst.size = (...args) => inst.check(_size(...args));\n });\n function map(keyType, valueType, params) {\n return new ZodMap({\n type: \"map\",\n keyType,\n valueType,\n ...util_exports.normalizeParams(params)\n });\n }\n var ZodSet = /* @__PURE__ */ $constructor(\"ZodSet\", (inst, def) => {\n $ZodSet.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json2, params) => setProcessor(inst, ctx, json2, params);\n inst.min = (...args) => inst.check(_minSize(...args));\n inst.nonempty = (params) => inst.check(_minSize(1, params));\n inst.max = (...args) => inst.check(_maxSize(...args));\n inst.size = (...args) => inst.check(_size(...args));\n });\n function set(valueType, params) {\n return new ZodSet({\n type: \"set\",\n valueType,\n ...util_exports.normalizeParams(params)\n });\n }\n var ZodEnum = /* @__PURE__ */ $constructor(\"ZodEnum\", (inst, def) => {\n $ZodEnum.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json2, params) => enumProcessor(inst, ctx, json2, params);\n inst.enum = def.entries;\n inst.options = Object.values(def.entries);\n const keys = new Set(Object.keys(def.entries));\n inst.extract = (values, params) => {\n const newEntries = {};\n for (const value of values) {\n if (keys.has(value)) {\n newEntries[value] = def.entries[value];\n } else\n throw new Error(`Key ${value} not found in enum`);\n }\n return new ZodEnum({\n ...def,\n checks: [],\n ...util_exports.normalizeParams(params),\n entries: newEntries\n });\n };\n inst.exclude = (values, params) => {\n const newEntries = { ...def.entries };\n for (const value of values) {\n if (keys.has(value)) {\n delete newEntries[value];\n } else\n throw new Error(`Key ${value} not found in enum`);\n }\n return new ZodEnum({\n ...def,\n checks: [],\n ...util_exports.normalizeParams(params),\n entries: newEntries\n });\n };\n });\n function _enum2(values, params) {\n const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;\n return new ZodEnum({\n type: \"enum\",\n entries,\n ...util_exports.normalizeParams(params)\n });\n }\n function nativeEnum(entries, params) {\n return new ZodEnum({\n type: \"enum\",\n entries,\n ...util_exports.normalizeParams(params)\n });\n }\n var ZodLiteral = /* @__PURE__ */ $constructor(\"ZodLiteral\", (inst, def) => {\n $ZodLiteral.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json2, params) => literalProcessor(inst, ctx, json2, params);\n inst.values = new Set(def.values);\n Object.defineProperty(inst, \"value\", {\n get() {\n if (def.values.length > 1) {\n throw new Error(\"This schema contains multiple valid literal values. Use `.values` instead.\");\n }\n return def.values[0];\n }\n });\n });\n function literal(value, params) {\n return new ZodLiteral({\n type: \"literal\",\n values: Array.isArray(value) ? value : [value],\n ...util_exports.normalizeParams(params)\n });\n }\n var ZodFile = /* @__PURE__ */ $constructor(\"ZodFile\", (inst, def) => {\n $ZodFile.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json2, params) => fileProcessor(inst, ctx, json2, params);\n inst.min = (size, params) => inst.check(_minSize(size, params));\n inst.max = (size, params) => inst.check(_maxSize(size, params));\n inst.mime = (types, params) => inst.check(_mime(Array.isArray(types) ? types : [types], params));\n });\n function file(params) {\n return _file(ZodFile, params);\n }\n var ZodTransform = /* @__PURE__ */ $constructor(\"ZodTransform\", (inst, def) => {\n $ZodTransform.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json2, params) => transformProcessor(inst, ctx, json2, params);\n inst._zod.parse = (payload, _ctx) => {\n if (_ctx.direction === \"backward\") {\n throw new $ZodEncodeError(inst.constructor.name);\n }\n payload.addIssue = (issue2) => {\n if (typeof issue2 === \"string\") {\n payload.issues.push(util_exports.issue(issue2, payload.value, def));\n } else {\n const _issue = issue2;\n if (_issue.fatal)\n _issue.continue = false;\n _issue.code ?? (_issue.code = \"custom\");\n _issue.input ?? (_issue.input = payload.value);\n _issue.inst ?? (_issue.inst = inst);\n payload.issues.push(util_exports.issue(_issue));\n }\n };\n const output = def.transform(payload.value, payload);\n if (output instanceof Promise) {\n return output.then((output2) => {\n payload.value = output2;\n return payload;\n });\n }\n payload.value = output;\n return payload;\n };\n });\n function transform(fn) {\n return new ZodTransform({\n type: \"transform\",\n transform: fn\n });\n }\n var ZodOptional = /* @__PURE__ */ $constructor(\"ZodOptional\", (inst, def) => {\n $ZodOptional.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json2, params) => optionalProcessor(inst, ctx, json2, params);\n inst.unwrap = () => inst._zod.def.innerType;\n });\n function optional(innerType) {\n return new ZodOptional({\n type: \"optional\",\n innerType\n });\n }\n var ZodExactOptional = /* @__PURE__ */ $constructor(\"ZodExactOptional\", (inst, def) => {\n $ZodExactOptional.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json2, params) => optionalProcessor(inst, ctx, json2, params);\n inst.unwrap = () => inst._zod.def.innerType;\n });\n function exactOptional(innerType) {\n return new ZodExactOptional({\n type: \"optional\",\n innerType\n });\n }\n var ZodNullable = /* @__PURE__ */ $constructor(\"ZodNullable\", (inst, def) => {\n $ZodNullable.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json2, params) => nullableProcessor(inst, ctx, json2, params);\n inst.unwrap = () => inst._zod.def.innerType;\n });\n function nullable(innerType) {\n return new ZodNullable({\n type: \"nullable\",\n innerType\n });\n }\n function nullish2(innerType) {\n return optional(nullable(innerType));\n }\n var ZodDefault = /* @__PURE__ */ $constructor(\"ZodDefault\", (inst, def) => {\n $ZodDefault.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json2, params) => defaultProcessor(inst, ctx, json2, params);\n inst.unwrap = () => inst._zod.def.innerType;\n inst.removeDefault = inst.unwrap;\n });\n function _default2(innerType, defaultValue) {\n return new ZodDefault({\n type: \"default\",\n innerType,\n get defaultValue() {\n return typeof defaultValue === \"function\" ? defaultValue() : util_exports.shallowClone(defaultValue);\n }\n });\n }\n var ZodPrefault = /* @__PURE__ */ $constructor(\"ZodPrefault\", (inst, def) => {\n $ZodPrefault.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json2, params) => prefaultProcessor(inst, ctx, json2, params);\n inst.unwrap = () => inst._zod.def.innerType;\n });\n function prefault(innerType, defaultValue) {\n return new ZodPrefault({\n type: \"prefault\",\n innerType,\n get defaultValue() {\n return typeof defaultValue === \"function\" ? defaultValue() : util_exports.shallowClone(defaultValue);\n }\n });\n }\n var ZodNonOptional = /* @__PURE__ */ $constructor(\"ZodNonOptional\", (inst, def) => {\n $ZodNonOptional.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json2, params) => nonoptionalProcessor(inst, ctx, json2, params);\n inst.unwrap = () => inst._zod.def.innerType;\n });\n function nonoptional(innerType, params) {\n return new ZodNonOptional({\n type: \"nonoptional\",\n innerType,\n ...util_exports.normalizeParams(params)\n });\n }\n var ZodSuccess = /* @__PURE__ */ $constructor(\"ZodSuccess\", (inst, def) => {\n $ZodSuccess.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json2, params) => successProcessor(inst, ctx, json2, params);\n inst.unwrap = () => inst._zod.def.innerType;\n });\n function success(innerType) {\n return new ZodSuccess({\n type: \"success\",\n innerType\n });\n }\n var ZodCatch = /* @__PURE__ */ $constructor(\"ZodCatch\", (inst, def) => {\n $ZodCatch.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json2, params) => catchProcessor(inst, ctx, json2, params);\n inst.unwrap = () => inst._zod.def.innerType;\n inst.removeCatch = inst.unwrap;\n });\n function _catch2(innerType, catchValue) {\n return new ZodCatch({\n type: \"catch\",\n innerType,\n catchValue: typeof catchValue === \"function\" ? catchValue : () => catchValue\n });\n }\n var ZodNaN = /* @__PURE__ */ $constructor(\"ZodNaN\", (inst, def) => {\n $ZodNaN.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json2, params) => nanProcessor(inst, ctx, json2, params);\n });\n function nan(params) {\n return _nan(ZodNaN, params);\n }\n var ZodPipe = /* @__PURE__ */ $constructor(\"ZodPipe\", (inst, def) => {\n $ZodPipe.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json2, params) => pipeProcessor(inst, ctx, json2, params);\n inst.in = def.in;\n inst.out = def.out;\n });\n function pipe(in_, out) {\n return new ZodPipe({\n type: \"pipe\",\n in: in_,\n out\n // ...util.normalizeParams(params),\n });\n }\n var ZodCodec = /* @__PURE__ */ $constructor(\"ZodCodec\", (inst, def) => {\n ZodPipe.init(inst, def);\n $ZodCodec.init(inst, def);\n });\n function codec(in_, out, params) {\n return new ZodCodec({\n type: \"pipe\",\n in: in_,\n out,\n transform: params.decode,\n reverseTransform: params.encode\n });\n }\n var ZodReadonly = /* @__PURE__ */ $constructor(\"ZodReadonly\", (inst, def) => {\n $ZodReadonly.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json2, params) => readonlyProcessor(inst, ctx, json2, params);\n inst.unwrap = () => inst._zod.def.innerType;\n });\n function readonly(innerType) {\n return new ZodReadonly({\n type: \"readonly\",\n innerType\n });\n }\n var ZodTemplateLiteral = /* @__PURE__ */ $constructor(\"ZodTemplateLiteral\", (inst, def) => {\n $ZodTemplateLiteral.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json2, params) => templateLiteralProcessor(inst, ctx, json2, params);\n });\n function templateLiteral(parts, params) {\n return new ZodTemplateLiteral({\n type: \"template_literal\",\n parts,\n ...util_exports.normalizeParams(params)\n });\n }\n var ZodLazy = /* @__PURE__ */ $constructor(\"ZodLazy\", (inst, def) => {\n $ZodLazy.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json2, params) => lazyProcessor(inst, ctx, json2, params);\n inst.unwrap = () => inst._zod.def.getter();\n });\n function lazy(getter) {\n return new ZodLazy({\n type: \"lazy\",\n getter\n });\n }\n var ZodPromise = /* @__PURE__ */ $constructor(\"ZodPromise\", (inst, def) => {\n $ZodPromise.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json2, params) => promiseProcessor(inst, ctx, json2, params);\n inst.unwrap = () => inst._zod.def.innerType;\n });\n function promise(innerType) {\n return new ZodPromise({\n type: \"promise\",\n innerType\n });\n }\n var ZodFunction = /* @__PURE__ */ $constructor(\"ZodFunction\", (inst, def) => {\n $ZodFunction.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json2, params) => functionProcessor(inst, ctx, json2, params);\n });\n function _function(params) {\n return new ZodFunction({\n type: \"function\",\n input: Array.isArray(params?.input) ? tuple(params?.input) : params?.input ?? array(unknown()),\n output: params?.output ?? unknown()\n });\n }\n var ZodCustom = /* @__PURE__ */ $constructor(\"ZodCustom\", (inst, def) => {\n $ZodCustom.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json2, params) => customProcessor(inst, ctx, json2, params);\n });\n function check(fn) {\n const ch = new $ZodCheck({\n check: \"custom\"\n // ...util.normalizeParams(params),\n });\n ch._zod.check = fn;\n return ch;\n }\n function custom(fn, _params) {\n return _custom(ZodCustom, fn ?? (() => true), _params);\n }\n function refine(fn, _params = {}) {\n return _refine(ZodCustom, fn, _params);\n }\n function superRefine(fn) {\n return _superRefine(fn);\n }\n var describe2 = describe;\n var meta2 = meta;\n function _instanceof(cls, params = {}) {\n const inst = new ZodCustom({\n type: \"custom\",\n check: \"custom\",\n fn: (data) => data instanceof cls,\n abort: true,\n ...util_exports.normalizeParams(params)\n });\n inst._zod.bag.Class = cls;\n inst._zod.check = (payload) => {\n if (!(payload.value instanceof cls)) {\n payload.issues.push({\n code: \"invalid_type\",\n expected: cls.name,\n input: payload.value,\n inst,\n path: [...inst._zod.def.path ?? []]\n });\n }\n };\n return inst;\n }\n var stringbool = (...args) => _stringbool({\n Codec: ZodCodec,\n Boolean: ZodBoolean,\n String: ZodString\n }, ...args);\n function json(params) {\n const jsonSchema = lazy(() => {\n return union([string2(params), number2(), boolean2(), _null3(), array(jsonSchema), record(string2(), jsonSchema)]);\n });\n return jsonSchema;\n }\n function preprocess(fn, schema) {\n return pipe(transform(fn), schema);\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/compat.js\n var ZodIssueCode = {\n invalid_type: \"invalid_type\",\n too_big: \"too_big\",\n too_small: \"too_small\",\n invalid_format: \"invalid_format\",\n not_multiple_of: \"not_multiple_of\",\n unrecognized_keys: \"unrecognized_keys\",\n invalid_union: \"invalid_union\",\n invalid_key: \"invalid_key\",\n invalid_element: \"invalid_element\",\n invalid_value: \"invalid_value\",\n custom: \"custom\"\n };\n function setErrorMap(map2) {\n config({\n customError: map2\n });\n }\n function getErrorMap() {\n return config().customError;\n }\n var ZodFirstPartyTypeKind;\n /* @__PURE__ */ (function(ZodFirstPartyTypeKind2) {\n })(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/from-json-schema.js\n var z = {\n ...schemas_exports2,\n ...checks_exports2,\n iso: iso_exports\n };\n var RECOGNIZED_KEYS = /* @__PURE__ */ new Set([\n // Schema identification\n \"$schema\",\n \"$ref\",\n \"$defs\",\n \"definitions\",\n // Core schema keywords\n \"$id\",\n \"id\",\n \"$comment\",\n \"$anchor\",\n \"$vocabulary\",\n \"$dynamicRef\",\n \"$dynamicAnchor\",\n // Type\n \"type\",\n \"enum\",\n \"const\",\n // Composition\n \"anyOf\",\n \"oneOf\",\n \"allOf\",\n \"not\",\n // Object\n \"properties\",\n \"required\",\n \"additionalProperties\",\n \"patternProperties\",\n \"propertyNames\",\n \"minProperties\",\n \"maxProperties\",\n // Array\n \"items\",\n \"prefixItems\",\n \"additionalItems\",\n \"minItems\",\n \"maxItems\",\n \"uniqueItems\",\n \"contains\",\n \"minContains\",\n \"maxContains\",\n // String\n \"minLength\",\n \"maxLength\",\n \"pattern\",\n \"format\",\n // Number\n \"minimum\",\n \"maximum\",\n \"exclusiveMinimum\",\n \"exclusiveMaximum\",\n \"multipleOf\",\n // Already handled metadata\n \"description\",\n \"default\",\n // Content\n \"contentEncoding\",\n \"contentMediaType\",\n \"contentSchema\",\n // Unsupported (error-throwing)\n \"unevaluatedItems\",\n \"unevaluatedProperties\",\n \"if\",\n \"then\",\n \"else\",\n \"dependentSchemas\",\n \"dependentRequired\",\n // OpenAPI\n \"nullable\",\n \"readOnly\"\n ]);\n function detectVersion(schema, defaultTarget) {\n const $schema = schema.$schema;\n if ($schema === \"https://json-schema.org/draft/2020-12/schema\") {\n return \"draft-2020-12\";\n }\n if ($schema === \"http://json-schema.org/draft-07/schema#\") {\n return \"draft-7\";\n }\n if ($schema === \"http://json-schema.org/draft-04/schema#\") {\n return \"draft-4\";\n }\n return defaultTarget ?? \"draft-2020-12\";\n }\n function resolveRef(ref, ctx) {\n if (!ref.startsWith(\"#\")) {\n throw new Error(\"External $ref is not supported, only local refs (#/...) are allowed\");\n }\n const path = ref.slice(1).split(\"/\").filter(Boolean);\n if (path.length === 0) {\n return ctx.rootSchema;\n }\n const defsKey = ctx.version === \"draft-2020-12\" ? \"$defs\" : \"definitions\";\n if (path[0] === defsKey) {\n const key = path[1];\n if (!key || !ctx.defs[key]) {\n throw new Error(`Reference not found: ${ref}`);\n }\n return ctx.defs[key];\n }\n throw new Error(`Reference not found: ${ref}`);\n }\n function convertBaseSchema(schema, ctx) {\n if (schema.not !== void 0) {\n if (typeof schema.not === \"object\" && Object.keys(schema.not).length === 0) {\n return z.never();\n }\n throw new Error(\"not is not supported in Zod (except { not: {} } for never)\");\n }\n if (schema.unevaluatedItems !== void 0) {\n throw new Error(\"unevaluatedItems is not supported\");\n }\n if (schema.unevaluatedProperties !== void 0) {\n throw new Error(\"unevaluatedProperties is not supported\");\n }\n if (schema.if !== void 0 || schema.then !== void 0 || schema.else !== void 0) {\n throw new Error(\"Conditional schemas (if/then/else) are not supported\");\n }\n if (schema.dependentSchemas !== void 0 || schema.dependentRequired !== void 0) {\n throw new Error(\"dependentSchemas and dependentRequired are not supported\");\n }\n if (schema.$ref) {\n const refPath = schema.$ref;\n if (ctx.refs.has(refPath)) {\n return ctx.refs.get(refPath);\n }\n if (ctx.processing.has(refPath)) {\n return z.lazy(() => {\n if (!ctx.refs.has(refPath)) {\n throw new Error(`Circular reference not resolved: ${refPath}`);\n }\n return ctx.refs.get(refPath);\n });\n }\n ctx.processing.add(refPath);\n const resolved = resolveRef(refPath, ctx);\n const zodSchema2 = convertSchema(resolved, ctx);\n ctx.refs.set(refPath, zodSchema2);\n ctx.processing.delete(refPath);\n return zodSchema2;\n }\n if (schema.enum !== void 0) {\n const enumValues = schema.enum;\n if (ctx.version === \"openapi-3.0\" && schema.nullable === true && enumValues.length === 1 && enumValues[0] === null) {\n return z.null();\n }\n if (enumValues.length === 0) {\n return z.never();\n }\n if (enumValues.length === 1) {\n return z.literal(enumValues[0]);\n }\n if (enumValues.every((v) => typeof v === \"string\")) {\n return z.enum(enumValues);\n }\n const literalSchemas = enumValues.map((v) => z.literal(v));\n if (literalSchemas.length < 2) {\n return literalSchemas[0];\n }\n return z.union([literalSchemas[0], literalSchemas[1], ...literalSchemas.slice(2)]);\n }\n if (schema.const !== void 0) {\n return z.literal(schema.const);\n }\n const type = schema.type;\n if (Array.isArray(type)) {\n const typeSchemas = type.map((t) => {\n const typeSchema = { ...schema, type: t };\n return convertBaseSchema(typeSchema, ctx);\n });\n if (typeSchemas.length === 0) {\n return z.never();\n }\n if (typeSchemas.length === 1) {\n return typeSchemas[0];\n }\n return z.union(typeSchemas);\n }\n if (!type) {\n return z.any();\n }\n let zodSchema;\n switch (type) {\n case \"string\": {\n let stringSchema = z.string();\n if (schema.format) {\n const format = schema.format;\n if (format === \"email\") {\n stringSchema = stringSchema.check(z.email());\n } else if (format === \"uri\" || format === \"uri-reference\") {\n stringSchema = stringSchema.check(z.url());\n } else if (format === \"uuid\" || format === \"guid\") {\n stringSchema = stringSchema.check(z.uuid());\n } else if (format === \"date-time\") {\n stringSchema = stringSchema.check(z.iso.datetime());\n } else if (format === \"date\") {\n stringSchema = stringSchema.check(z.iso.date());\n } else if (format === \"time\") {\n stringSchema = stringSchema.check(z.iso.time());\n } else if (format === \"duration\") {\n stringSchema = stringSchema.check(z.iso.duration());\n } else if (format === \"ipv4\") {\n stringSchema = stringSchema.check(z.ipv4());\n } else if (format === \"ipv6\") {\n stringSchema = stringSchema.check(z.ipv6());\n } else if (format === \"mac\") {\n stringSchema = stringSchema.check(z.mac());\n } else if (format === \"cidr\") {\n stringSchema = stringSchema.check(z.cidrv4());\n } else if (format === \"cidr-v6\") {\n stringSchema = stringSchema.check(z.cidrv6());\n } else if (format === \"base64\") {\n stringSchema = stringSchema.check(z.base64());\n } else if (format === \"base64url\") {\n stringSchema = stringSchema.check(z.base64url());\n } else if (format === \"e164\") {\n stringSchema = stringSchema.check(z.e164());\n } else if (format === \"jwt\") {\n stringSchema = stringSchema.check(z.jwt());\n } else if (format === \"emoji\") {\n stringSchema = stringSchema.check(z.emoji());\n } else if (format === \"nanoid\") {\n stringSchema = stringSchema.check(z.nanoid());\n } else if (format === \"cuid\") {\n stringSchema = stringSchema.check(z.cuid());\n } else if (format === \"cuid2\") {\n stringSchema = stringSchema.check(z.cuid2());\n } else if (format === \"ulid\") {\n stringSchema = stringSchema.check(z.ulid());\n } else if (format === \"xid\") {\n stringSchema = stringSchema.check(z.xid());\n } else if (format === \"ksuid\") {\n stringSchema = stringSchema.check(z.ksuid());\n }\n }\n if (typeof schema.minLength === \"number\") {\n stringSchema = stringSchema.min(schema.minLength);\n }\n if (typeof schema.maxLength === \"number\") {\n stringSchema = stringSchema.max(schema.maxLength);\n }\n if (schema.pattern) {\n stringSchema = stringSchema.regex(new RegExp(schema.pattern));\n }\n zodSchema = stringSchema;\n break;\n }\n case \"number\":\n case \"integer\": {\n let numberSchema = type === \"integer\" ? z.number().int() : z.number();\n if (typeof schema.minimum === \"number\") {\n numberSchema = numberSchema.min(schema.minimum);\n }\n if (typeof schema.maximum === \"number\") {\n numberSchema = numberSchema.max(schema.maximum);\n }\n if (typeof schema.exclusiveMinimum === \"number\") {\n numberSchema = numberSchema.gt(schema.exclusiveMinimum);\n } else if (schema.exclusiveMinimum === true && typeof schema.minimum === \"number\") {\n numberSchema = numberSchema.gt(schema.minimum);\n }\n if (typeof schema.exclusiveMaximum === \"number\") {\n numberSchema = numberSchema.lt(schema.exclusiveMaximum);\n } else if (schema.exclusiveMaximum === true && typeof schema.maximum === \"number\") {\n numberSchema = numberSchema.lt(schema.maximum);\n }\n if (typeof schema.multipleOf === \"number\") {\n numberSchema = numberSchema.multipleOf(schema.multipleOf);\n }\n zodSchema = numberSchema;\n break;\n }\n case \"boolean\": {\n zodSchema = z.boolean();\n break;\n }\n case \"null\": {\n zodSchema = z.null();\n break;\n }\n case \"object\": {\n const shape = {};\n const properties = schema.properties || {};\n const requiredSet = new Set(schema.required || []);\n for (const [key, propSchema] of Object.entries(properties)) {\n const propZodSchema = convertSchema(propSchema, ctx);\n shape[key] = requiredSet.has(key) ? propZodSchema : propZodSchema.optional();\n }\n if (schema.propertyNames) {\n const keySchema = convertSchema(schema.propertyNames, ctx);\n const valueSchema = schema.additionalProperties && typeof schema.additionalProperties === \"object\" ? convertSchema(schema.additionalProperties, ctx) : z.any();\n if (Object.keys(shape).length === 0) {\n zodSchema = z.record(keySchema, valueSchema);\n break;\n }\n const objectSchema2 = z.object(shape).passthrough();\n const recordSchema2 = z.looseRecord(keySchema, valueSchema);\n zodSchema = z.intersection(objectSchema2, recordSchema2);\n break;\n }\n if (schema.patternProperties) {\n const patternProps = schema.patternProperties;\n const patternKeys = Object.keys(patternProps);\n const looseRecords = [];\n for (const pattern of patternKeys) {\n const patternValue = convertSchema(patternProps[pattern], ctx);\n const keySchema = z.string().regex(new RegExp(pattern));\n looseRecords.push(z.looseRecord(keySchema, patternValue));\n }\n const schemasToIntersect = [];\n if (Object.keys(shape).length > 0) {\n schemasToIntersect.push(z.object(shape).passthrough());\n }\n schemasToIntersect.push(...looseRecords);\n if (schemasToIntersect.length === 0) {\n zodSchema = z.object({}).passthrough();\n } else if (schemasToIntersect.length === 1) {\n zodSchema = schemasToIntersect[0];\n } else {\n let result = z.intersection(schemasToIntersect[0], schemasToIntersect[1]);\n for (let i = 2; i < schemasToIntersect.length; i++) {\n result = z.intersection(result, schemasToIntersect[i]);\n }\n zodSchema = result;\n }\n break;\n }\n const objectSchema = z.object(shape);\n if (schema.additionalProperties === false) {\n zodSchema = objectSchema.strict();\n } else if (typeof schema.additionalProperties === \"object\") {\n zodSchema = objectSchema.catchall(convertSchema(schema.additionalProperties, ctx));\n } else {\n zodSchema = objectSchema.passthrough();\n }\n break;\n }\n case \"array\": {\n const prefixItems = schema.prefixItems;\n const items = schema.items;\n if (prefixItems && Array.isArray(prefixItems)) {\n const tupleItems = prefixItems.map((item) => convertSchema(item, ctx));\n const rest = items && typeof items === \"object\" && !Array.isArray(items) ? convertSchema(items, ctx) : void 0;\n if (rest) {\n zodSchema = z.tuple(tupleItems).rest(rest);\n } else {\n zodSchema = z.tuple(tupleItems);\n }\n if (typeof schema.minItems === \"number\") {\n zodSchema = zodSchema.check(z.minLength(schema.minItems));\n }\n if (typeof schema.maxItems === \"number\") {\n zodSchema = zodSchema.check(z.maxLength(schema.maxItems));\n }\n } else if (Array.isArray(items)) {\n const tupleItems = items.map((item) => convertSchema(item, ctx));\n const rest = schema.additionalItems && typeof schema.additionalItems === \"object\" ? convertSchema(schema.additionalItems, ctx) : void 0;\n if (rest) {\n zodSchema = z.tuple(tupleItems).rest(rest);\n } else {\n zodSchema = z.tuple(tupleItems);\n }\n if (typeof schema.minItems === \"number\") {\n zodSchema = zodSchema.check(z.minLength(schema.minItems));\n }\n if (typeof schema.maxItems === \"number\") {\n zodSchema = zodSchema.check(z.maxLength(schema.maxItems));\n }\n } else if (items !== void 0) {\n const element = convertSchema(items, ctx);\n let arraySchema = z.array(element);\n if (typeof schema.minItems === \"number\") {\n arraySchema = arraySchema.min(schema.minItems);\n }\n if (typeof schema.maxItems === \"number\") {\n arraySchema = arraySchema.max(schema.maxItems);\n }\n zodSchema = arraySchema;\n } else {\n zodSchema = z.array(z.any());\n }\n break;\n }\n default:\n throw new Error(`Unsupported type: ${type}`);\n }\n if (schema.description) {\n zodSchema = zodSchema.describe(schema.description);\n }\n if (schema.default !== void 0) {\n zodSchema = zodSchema.default(schema.default);\n }\n return zodSchema;\n }\n function convertSchema(schema, ctx) {\n if (typeof schema === \"boolean\") {\n return schema ? z.any() : z.never();\n }\n let baseSchema = convertBaseSchema(schema, ctx);\n const hasExplicitType = schema.type || schema.enum !== void 0 || schema.const !== void 0;\n if (schema.anyOf && Array.isArray(schema.anyOf)) {\n const options = schema.anyOf.map((s) => convertSchema(s, ctx));\n const anyOfUnion = z.union(options);\n baseSchema = hasExplicitType ? z.intersection(baseSchema, anyOfUnion) : anyOfUnion;\n }\n if (schema.oneOf && Array.isArray(schema.oneOf)) {\n const options = schema.oneOf.map((s) => convertSchema(s, ctx));\n const oneOfUnion = z.xor(options);\n baseSchema = hasExplicitType ? z.intersection(baseSchema, oneOfUnion) : oneOfUnion;\n }\n if (schema.allOf && Array.isArray(schema.allOf)) {\n if (schema.allOf.length === 0) {\n baseSchema = hasExplicitType ? baseSchema : z.any();\n } else {\n let result = hasExplicitType ? baseSchema : convertSchema(schema.allOf[0], ctx);\n const startIdx = hasExplicitType ? 0 : 1;\n for (let i = startIdx; i < schema.allOf.length; i++) {\n result = z.intersection(result, convertSchema(schema.allOf[i], ctx));\n }\n baseSchema = result;\n }\n }\n if (schema.nullable === true && ctx.version === \"openapi-3.0\") {\n baseSchema = z.nullable(baseSchema);\n }\n if (schema.readOnly === true) {\n baseSchema = z.readonly(baseSchema);\n }\n const extraMeta = {};\n const coreMetadataKeys = [\"$id\", \"id\", \"$comment\", \"$anchor\", \"$vocabulary\", \"$dynamicRef\", \"$dynamicAnchor\"];\n for (const key of coreMetadataKeys) {\n if (key in schema) {\n extraMeta[key] = schema[key];\n }\n }\n const contentMetadataKeys = [\"contentEncoding\", \"contentMediaType\", \"contentSchema\"];\n for (const key of contentMetadataKeys) {\n if (key in schema) {\n extraMeta[key] = schema[key];\n }\n }\n for (const key of Object.keys(schema)) {\n if (!RECOGNIZED_KEYS.has(key)) {\n extraMeta[key] = schema[key];\n }\n }\n if (Object.keys(extraMeta).length > 0) {\n ctx.registry.add(baseSchema, extraMeta);\n }\n return baseSchema;\n }\n function fromJSONSchema(schema, params) {\n if (typeof schema === \"boolean\") {\n return schema ? z.any() : z.never();\n }\n const version2 = detectVersion(schema, params?.defaultTarget);\n const defs = schema.$defs || schema.definitions || {};\n const ctx = {\n version: version2,\n defs,\n refs: /* @__PURE__ */ new Map(),\n processing: /* @__PURE__ */ new Set(),\n rootSchema: schema,\n registry: params?.registry ?? globalRegistry\n };\n return convertSchema(schema, ctx);\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/coerce.js\n var coerce_exports = {};\n __export(coerce_exports, {\n bigint: () => bigint3,\n boolean: () => boolean3,\n date: () => date4,\n number: () => number3,\n string: () => string3\n });\n function string3(params) {\n return _coercedString(ZodString, params);\n }\n function number3(params) {\n return _coercedNumber(ZodNumber, params);\n }\n function boolean3(params) {\n return _coercedBoolean(ZodBoolean, params);\n }\n function bigint3(params) {\n return _coercedBigint(ZodBigInt, params);\n }\n function date4(params) {\n return _coercedDate(ZodDate, params);\n }\n\n // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/external.js\n config(en_default());\n\n // ../domain/src/shared-types.ts\n var reasoningLevelValues = [\n \"low\",\n \"medium\",\n \"high\",\n \"xhigh\",\n \"ultracode\",\n \"max\"\n ];\n var reasoningLevelSchema = external_exports.enum(reasoningLevelValues);\n var serviceTierSchema = external_exports.enum([\"fast\", \"default\"]);\n var instructionModeValues = [\"append\", \"replace\"];\n var instructionModeSchema = external_exports.enum(instructionModeValues);\n var permissionModeValues = [\n \"full\",\n \"workspace-write\",\n \"readonly\"\n ];\n var permissionModeSchema = external_exports.enum(permissionModeValues);\n var permissionEscalationValues = [\"ask\", \"deny\"];\n var permissionEscalationSchema = external_exports.enum(permissionEscalationValues);\n var promptInputVisibilityValues = [\"agent-only\"];\n var promptInputVisibilitySchema = external_exports.enum(promptInputVisibilityValues);\n var promptInputVisibilityFields = {\n visibility: promptInputVisibilitySchema.optional()\n };\n var promptInputSchema = external_exports.discriminatedUnion(\"type\", [\n external_exports.object({\n type: external_exports.literal(\"text\"),\n text: external_exports.string(),\n ...promptInputVisibilityFields\n }),\n external_exports.object({\n type: external_exports.literal(\"image\"),\n url: external_exports.string().url(),\n ...promptInputVisibilityFields\n }),\n external_exports.object({\n type: external_exports.literal(\"localImage\"),\n path: external_exports.string(),\n ...promptInputVisibilityFields\n }),\n external_exports.object({\n type: external_exports.literal(\"localFile\"),\n path: external_exports.string(),\n name: external_exports.string().optional(),\n sizeBytes: external_exports.number().int().nonnegative().optional(),\n mimeType: external_exports.string().optional(),\n ...promptInputVisibilityFields\n })\n ]);\n var threadExecutionSourceSchema = external_exports.enum([\n \"client/thread/start\",\n \"client/turn/requested\",\n \"client/turn/start\"\n ]);\n var callerExecutionInputSourceValues = [\n \"explicit\",\n \"client-preference\"\n ];\n var callerExecutionInputSourceSchema = external_exports.enum(\n callerExecutionInputSourceValues\n );\n var threadExecutionOptionsSchema = external_exports.object({\n model: external_exports.string().optional(),\n serviceTier: serviceTierSchema.optional(),\n reasoningLevel: reasoningLevelSchema.optional(),\n permissionMode: permissionModeSchema.optional(),\n source: threadExecutionSourceSchema.optional(),\n seq: external_exports.number().int().optional()\n });\n var resolvedThreadExecutionOptionsSchema = threadExecutionOptionsSchema.extend({\n model: external_exports.string().min(1),\n serviceTier: serviceTierSchema,\n reasoningLevel: reasoningLevelSchema,\n permissionMode: permissionModeSchema,\n source: threadExecutionSourceSchema\n });\n var runtimePermissionPolicySchema = external_exports.discriminatedUnion(\n \"permissionMode\",\n [\n external_exports.object({\n permissionMode: external_exports.literal(\"full\"),\n permissionEscalation: external_exports.null()\n }),\n external_exports.object({\n permissionMode: external_exports.literal(\"workspace-write\"),\n permissionEscalation: permissionEscalationSchema\n }),\n external_exports.object({\n permissionMode: external_exports.literal(\"readonly\"),\n permissionEscalation: permissionEscalationSchema\n })\n ]\n );\n var runtimeThreadExecutionBaseOptionsSchema = external_exports.object({\n model: external_exports.string().min(1),\n serviceTier: serviceTierSchema,\n reasoningLevel: reasoningLevelSchema,\n /**\n * Server-owned product policy: whether the provider session may use the\n * Workflows feature. Filled explicitly at the server boundary (per-provider\n * policy), never defaulted downstream.\n */\n workflowsEnabled: external_exports.boolean()\n });\n var runtimeThreadExecutionOptionsSchema = runtimeThreadExecutionBaseOptionsSchema.and(runtimePermissionPolicySchema);\n var projectExecutionDefaultsSchema = external_exports.object({\n providerId: external_exports.string().min(1),\n model: external_exports.string().min(1),\n serviceTier: serviceTierSchema,\n reasoningLevel: reasoningLevelSchema,\n permissionMode: permissionModeSchema\n });\n\n // ../domain/src/feature-flags.ts\n var featureFlagsSchema = external_exports.object({\n placeholder: external_exports.boolean()\n });\n\n // ../domain/src/host-list-limits.ts\n var FILE_LIST_QUERY_MAX_LENGTH = 256;\n var FILE_LIST_LIMIT_MAX = 1e4;\n var BRANCH_LIST_QUERY_MAX_LENGTH = 256;\n var BRANCH_LIST_LIMIT_MAX = 1e3;\n\n // ../domain/src/git-checkout.ts\n var gitBranchForbiddenCharacterPattern = /[\\u0000-\\u001f\\u007f\\\\:~^?*\\[]/u;\n var gitBranchWhitespacePattern = /[ \\t]/u;\n var gitReservedBranchNames = /* @__PURE__ */ new Set([\n \"AUTO_MERGE\",\n \"BISECT_HEAD\",\n \"CHERRY_PICK_HEAD\",\n \"FETCH_HEAD\",\n \"HEAD\",\n \"MERGE_HEAD\",\n \"ORIG_HEAD\",\n \"REVERT_HEAD\"\n ]);\n function isValidGitBranchName(name) {\n const components = name.split(\"/\");\n return name.length > 0 && name.trim().length > 0 && !name.startsWith(\"-\") && !name.startsWith(\"/\") && name !== \"@\" && !gitReservedBranchNames.has(name) && !gitBranchForbiddenCharacterPattern.test(name) && !gitBranchWhitespacePattern.test(name) && !name.includes(\"..\") && !name.includes(\"@{\") && !name.includes(\"//\") && !name.endsWith(\"/\") && !name.endsWith(\".\") && components.every(\n (component) => component.length > 0 && !component.startsWith(\".\") && !component.endsWith(\".lock\")\n );\n }\n var gitBranchNameSchema = external_exports.string().refine(isValidGitBranchName, { message: \"Invalid git branch name\" });\n var gitCheckoutRefSchema = external_exports.discriminatedUnion(\"kind\", [\n external_exports.object({\n kind: external_exports.literal(\"branch\"),\n branchName: external_exports.string().min(1),\n headSha: external_exports.string().min(1).nullable()\n }),\n external_exports.object({\n kind: external_exports.literal(\"detached\"),\n headSha: external_exports.string().min(1).nullable()\n }),\n external_exports.object({\n kind: external_exports.literal(\"unborn\"),\n branchName: external_exports.string().min(1).nullable()\n }),\n external_exports.object({\n kind: external_exports.literal(\"unknown\"),\n reason: external_exports.string().min(1)\n })\n ]);\n var workspaceGitOperationSchema = external_exports.discriminatedUnion(\"kind\", [\n external_exports.object({ kind: external_exports.literal(\"none\") }),\n external_exports.object({\n kind: external_exports.literal(\"merge\"),\n hasConflicts: external_exports.boolean()\n }),\n external_exports.object({\n kind: external_exports.literal(\"rebase\"),\n hasConflicts: external_exports.boolean()\n }),\n external_exports.object({\n kind: external_exports.literal(\"cherry-pick\"),\n hasConflicts: external_exports.boolean()\n }),\n external_exports.object({\n kind: external_exports.literal(\"revert\"),\n hasConflicts: external_exports.boolean()\n }),\n external_exports.object({\n kind: external_exports.literal(\"unknown\"),\n reason: external_exports.string().min(1),\n hasConflicts: external_exports.boolean()\n })\n ]);\n var gitBranchRefClassificationSchema = external_exports.object({\n name: external_exports.string().min(1),\n kind: external_exports.enum([\"local\", \"remote\", \"missing\"])\n });\n var projectSourceCheckoutSchema = external_exports.object({\n /** Local branches under refs/heads, safe for checkout and write targets. */\n branches: external_exports.array(external_exports.string()),\n branchesTruncated: external_exports.boolean(),\n checkout: gitCheckoutRefSchema,\n defaultBranch: external_exports.string().min(1).nullable(),\n hasUncommittedChanges: external_exports.boolean(),\n operation: workspaceGitOperationSchema,\n /** Remote-tracking branches under refs/remotes, for base/diff selection. */\n remoteBranches: external_exports.array(external_exports.string()),\n remoteBranchesTruncated: external_exports.boolean(),\n /**\n * Exact classification of the requested branch/ref, resolved before branch\n * list pagination so callers can validate selected refs even when they are\n * not present in the current page.\n */\n selectedBranch: gitBranchRefClassificationSchema.nullable()\n });\n\n // ../domain/src/apps.ts\n var APPLICATION_ID_MAX_LENGTH = 64;\n var APPLICATION_ID_PATTERN = /^[a-z0-9][a-z0-9-]*$/u;\n var APP_DATA_PATH_SEGMENT_PATTERN = /^[A-Za-z0-9._-]{1,80}$/u;\n var APP_DATA_PATH_MAX_DEPTH = 8;\n var APP_DATA_PATH_MAX_LENGTH = 512;\n var applicationIdSchema = external_exports.string().min(1).max(APPLICATION_ID_MAX_LENGTH).regex(\n APPLICATION_ID_PATTERN,\n \"Application id must be a lowercase slug containing only letters, numbers, and hyphens\"\n );\n var appDataPathSchema = external_exports.string().superRefine((value, context) => {\n if (value.length === 0 || value.length > APP_DATA_PATH_MAX_LENGTH || value.includes(\"\\0\") || value.includes(\"\\\\\") || value.startsWith(\"/\") || value.endsWith(\"/\")) {\n context.addIssue({\n code: \"custom\",\n message: \"Invalid app data path\"\n });\n return;\n }\n const segments = value.split(\"/\");\n if (segments.length > APP_DATA_PATH_MAX_DEPTH) {\n context.addIssue({\n code: \"custom\",\n message: \"App data path is too deep\"\n });\n return;\n }\n for (const segment of segments) {\n if (segment === \".\" || segment === \"..\" || segment.startsWith(\".\") || !APP_DATA_PATH_SEGMENT_PATTERN.test(segment)) {\n context.addIssue({\n code: \"custom\",\n message: \"Invalid app data path segment\"\n });\n return;\n }\n }\n });\n\n // ../domain/src/terminal.ts\n var TERMINAL_COLS_MAX = 500;\n var TERMINAL_ROWS_MAX = 200;\n var TERMINAL_DATA_MAX_BYTES = 64 * 1024;\n var TERMINAL_DATA_MAX_BASE64_LENGTH = Math.ceil(TERMINAL_DATA_MAX_BYTES / 3) * 4;\n var terminalBase64DataPattern = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/u;\n var terminalSessionStatusValues = [\n \"starting\",\n \"running\",\n \"disconnected\",\n \"exited\"\n ];\n var terminalSessionStatusSchema = external_exports.enum(\n terminalSessionStatusValues\n );\n var terminalSessionCloseReasonValues = [\n \"user\",\n \"process-exit\",\n \"daemon-disconnect\",\n \"environment-destroyed\",\n \"thread-archived\",\n \"thread-deleted\",\n \"open-timeout\"\n ];\n var terminalSessionCloseReasonSchema = external_exports.enum(\n terminalSessionCloseReasonValues\n );\n function getTerminalBase64DecodedByteLength(value) {\n const padding = value.endsWith(\"==\") ? 2 : value.endsWith(\"=\") ? 1 : 0;\n return value.length / 4 * 3 - padding;\n }\n var terminalColsSchema = external_exports.number().int().positive().max(\n TERMINAL_COLS_MAX\n );\n var terminalRowsSchema = external_exports.number().int().positive().max(\n TERMINAL_ROWS_MAX\n );\n var terminalDataBase64Schema = external_exports.string().min(1).max(TERMINAL_DATA_MAX_BASE64_LENGTH).regex(terminalBase64DataPattern).refine(\n (value) => getTerminalBase64DecodedByteLength(value) <= TERMINAL_DATA_MAX_BYTES,\n {\n message: `Terminal data must decode to ${TERMINAL_DATA_MAX_BYTES} bytes or less`\n }\n );\n\n // ../domain/src/prompt-history.ts\n var promptHistoryScopeValues = [\"project\", \"thread\"];\n var promptHistoryScopeSchema = external_exports.enum(promptHistoryScopeValues);\n var promptHistoryEntrySchema = external_exports.object({\n id: external_exports.string().min(1),\n createdAt: external_exports.number(),\n input: external_exports.array(promptInputSchema).min(1)\n });\n\n // ../domain/src/pending-interactions.ts\n var pendingInteractionStatusSchema = external_exports.enum([\n \"pending\",\n \"resolving\",\n \"resolved\",\n \"interrupted\",\n \"expired\"\n ]);\n var pendingInteractionCommandActionSchema = external_exports.discriminatedUnion(\n \"type\",\n [\n external_exports.object({\n type: external_exports.literal(\"read\"),\n command: external_exports.string(),\n name: external_exports.string(),\n path: external_exports.string()\n }),\n external_exports.object({\n type: external_exports.literal(\"listFiles\"),\n command: external_exports.string(),\n path: external_exports.string().nullable()\n }),\n external_exports.object({\n type: external_exports.literal(\"search\"),\n command: external_exports.string(),\n query: external_exports.string().nullable(),\n path: external_exports.string().nullable()\n }),\n external_exports.object({\n type: external_exports.literal(\"unknown\"),\n command: external_exports.string()\n })\n ]\n );\n var pendingInteractionNetworkPermissionsSchema = external_exports.object({\n enabled: external_exports.boolean().nullable()\n });\n var pendingInteractionFileSystemPermissionsSchema = external_exports.object({\n read: external_exports.array(external_exports.string()),\n write: external_exports.array(external_exports.string())\n });\n var pendingInteractionMacOsPreferencesPermissionSchema = external_exports.enum([\n \"none\",\n \"read_only\",\n \"read_write\"\n ]);\n var pendingInteractionMacOsContactsPermissionSchema = external_exports.enum([\n \"none\",\n \"read_only\",\n \"read_write\"\n ]);\n var pendingInteractionMacOsAutomationPermissionSchema = external_exports.union([\n external_exports.literal(\"none\"),\n external_exports.literal(\"all\"),\n external_exports.object({\n kind: external_exports.literal(\"bundle_ids\"),\n bundleIds: external_exports.array(external_exports.string())\n })\n ]);\n var pendingInteractionMacOsPermissionsSchema = external_exports.object({\n preferences: pendingInteractionMacOsPreferencesPermissionSchema,\n automations: pendingInteractionMacOsAutomationPermissionSchema,\n launchServices: external_exports.boolean(),\n accessibility: external_exports.boolean(),\n calendar: external_exports.boolean(),\n reminders: external_exports.boolean(),\n contacts: pendingInteractionMacOsContactsPermissionSchema\n });\n var pendingInteractionRequestedPermissionProfileSchema = external_exports.object({\n network: pendingInteractionNetworkPermissionsSchema.nullable(),\n fileSystem: pendingInteractionFileSystemPermissionsSchema.nullable(),\n macos: pendingInteractionMacOsPermissionsSchema.nullable()\n });\n var pendingInteractionGrantablePermissionProfileSchema = external_exports.object({\n network: pendingInteractionNetworkPermissionsSchema.nullable(),\n fileSystem: pendingInteractionFileSystemPermissionsSchema.nullable()\n }).strict();\n var pendingInteractionGrantedPermissionProfileSchema = pendingInteractionGrantablePermissionProfileSchema;\n var pendingInteractionApprovalDecisionSchema = external_exports.enum([\n \"allow_once\",\n \"allow_for_session\",\n \"deny\"\n ]);\n var pendingInteractionFileChangeWriteScopeSchema = external_exports.string().min(1);\n var pendingInteractionCommandApprovalSubjectSchema = external_exports.object({\n kind: external_exports.literal(\"command\"),\n itemId: external_exports.string().min(1),\n command: external_exports.string().min(1),\n cwd: external_exports.string().nullable(),\n actions: external_exports.array(pendingInteractionCommandActionSchema),\n sessionGrant: pendingInteractionGrantablePermissionProfileSchema.nullable()\n });\n var pendingInteractionFileChangeApprovalSubjectSchema = external_exports.object({\n kind: external_exports.literal(\"file_change\"),\n itemId: external_exports.string().min(1),\n writeScope: pendingInteractionFileChangeWriteScopeSchema.nullable(),\n sessionGrant: pendingInteractionGrantablePermissionProfileSchema.nullable()\n });\n var pendingInteractionPermissionGrantApprovalSubjectSchema = external_exports.object({\n kind: external_exports.literal(\"permission_grant\"),\n itemId: external_exports.string().min(1),\n toolName: external_exports.string().nullable(),\n permissions: pendingInteractionGrantablePermissionProfileSchema\n });\n var pendingInteractionApprovalSubjectSchema = external_exports.discriminatedUnion(\n \"kind\",\n [\n pendingInteractionCommandApprovalSubjectSchema,\n pendingInteractionFileChangeApprovalSubjectSchema,\n pendingInteractionPermissionGrantApprovalSubjectSchema\n ]\n );\n var approvalPendingInteractionPayloadSchema = external_exports.object({\n kind: external_exports.literal(\"approval\"),\n subject: pendingInteractionApprovalSubjectSchema,\n reason: external_exports.string().nullable(),\n availableDecisions: external_exports.array(pendingInteractionApprovalDecisionSchema).min(1)\n });\n var USER_QUESTION_MAX_QUESTIONS = 4;\n var USER_QUESTION_MAX_OPTIONS = 4;\n var USER_QUESTION_MAX_SELECTED = 4;\n var USER_QUESTION_MAX_FREE_TEXT_LENGTH = 4096;\n var pendingInteractionUserQuestionIdSchema = external_exports.string().min(1).refine((value) => value.trim().length > 0, {\n message: \"User question ids cannot be blank\"\n });\n var pendingInteractionUserQuestionPromptSchema = external_exports.string().min(1).refine((value) => value.trim().length > 0, {\n message: \"User question prompts cannot be blank\"\n });\n var pendingInteractionUserQuestionShortLabelSchema = external_exports.string().min(1).refine((value) => value.trim().length > 0, {\n message: \"User question short labels cannot be blank\"\n });\n var pendingInteractionUserQuestionOptionValueSchema = external_exports.string().min(1).refine((value) => value.trim().length > 0, {\n message: \"User question option values cannot be blank\"\n });\n var pendingInteractionUserQuestionOptionLabelSchema = external_exports.string().min(1).refine((value) => value.trim().length > 0, {\n message: \"User question option labels cannot be blank\"\n });\n var pendingInteractionUserQuestionOptionDescriptionSchema = external_exports.string().min(1).refine((value) => value.trim().length > 0, {\n message: \"User question option descriptions cannot be blank\"\n });\n var pendingInteractionUserQuestionFreeTextSchema = external_exports.string().min(1).max(\n USER_QUESTION_MAX_FREE_TEXT_LENGTH,\n `User question free text cannot exceed ${USER_QUESTION_MAX_FREE_TEXT_LENGTH} characters`\n ).refine((value) => value.trim().length > 0, {\n message: \"User question free text cannot be blank\"\n });\n var pendingInteractionUserQuestionOptionSchema = external_exports.object({\n value: pendingInteractionUserQuestionOptionValueSchema,\n label: pendingInteractionUserQuestionOptionLabelSchema,\n description: pendingInteractionUserQuestionOptionDescriptionSchema.optional()\n });\n var pendingInteractionUserQuestionQuestionSchema = external_exports.object({\n id: pendingInteractionUserQuestionIdSchema,\n prompt: pendingInteractionUserQuestionPromptSchema,\n shortLabel: pendingInteractionUserQuestionShortLabelSchema.optional(),\n multiSelect: external_exports.boolean(),\n options: external_exports.array(pendingInteractionUserQuestionOptionSchema).max(\n USER_QUESTION_MAX_OPTIONS,\n `User questions cannot include more than ${USER_QUESTION_MAX_OPTIONS} options`\n ).optional(),\n allowFreeText: external_exports.boolean()\n }).superRefine((question, context) => {\n const optionValues = /* @__PURE__ */ new Set();\n question.options?.forEach((option, index) => {\n if (optionValues.has(option.value)) {\n context.addIssue({\n code: external_exports.ZodIssueCode.custom,\n message: \"User question option values must be unique\",\n path: [\"options\", index, \"value\"]\n });\n return;\n }\n optionValues.add(option.value);\n });\n }).refine(\n (question) => question.allowFreeText || (question.options?.length ?? 0) > 0,\n {\n message: \"User questions must allow free text or provide at least one option\",\n path: [\"options\"]\n }\n );\n var userQuestionPendingInteractionPayloadSchema = external_exports.object({\n kind: external_exports.literal(\"user_question\"),\n questions: external_exports.array(pendingInteractionUserQuestionQuestionSchema).min(1).max(\n USER_QUESTION_MAX_QUESTIONS,\n `User questions cannot include more than ${USER_QUESTION_MAX_QUESTIONS} questions`\n )\n }).superRefine((payload, context) => {\n const questionIds = /* @__PURE__ */ new Set();\n payload.questions.forEach((question, index) => {\n if (questionIds.has(question.id)) {\n context.addIssue({\n code: external_exports.ZodIssueCode.custom,\n message: \"User question ids must be unique\",\n path: [\"questions\", index, \"id\"]\n });\n return;\n }\n questionIds.add(question.id);\n });\n });\n var pendingInteractionPayloadSchema = external_exports.discriminatedUnion(\"kind\", [\n approvalPendingInteractionPayloadSchema,\n userQuestionPendingInteractionPayloadSchema\n ]);\n var approvalDecisionDiscriminatorError = \"Invalid discriminator value. Expected 'allow_once' | 'allow_for_session' | 'deny'\";\n var approvalPendingInteractionResolutionSchema = external_exports.discriminatedUnion(\n \"decision\",\n [\n external_exports.object({\n decision: external_exports.literal(\"allow_once\"),\n grantedPermissions: pendingInteractionGrantedPermissionProfileSchema.nullable()\n }),\n external_exports.object({\n decision: external_exports.literal(\"allow_for_session\"),\n grantedPermissions: pendingInteractionGrantedPermissionProfileSchema.nullable()\n }),\n external_exports.object({\n decision: external_exports.literal(\"deny\")\n })\n ],\n approvalDecisionDiscriminatorError\n );\n var pendingInteractionUserAnswerSchema = external_exports.object({\n selected: external_exports.array(external_exports.string().min(1)).max(\n USER_QUESTION_MAX_SELECTED,\n `User question selected choices cannot exceed ${USER_QUESTION_MAX_SELECTED}`\n ),\n freeText: pendingInteractionUserQuestionFreeTextSchema.optional()\n });\n var userQuestionPendingInteractionResolutionSchema = external_exports.object({\n kind: external_exports.literal(\"user_answer\"),\n answers: external_exports.record(external_exports.string().min(1), pendingInteractionUserAnswerSchema)\n });\n var pendingInteractionResolutionSchema = external_exports.union(\n [\n approvalPendingInteractionResolutionSchema,\n userQuestionPendingInteractionResolutionSchema\n ],\n approvalDecisionDiscriminatorError\n );\n var pendingInteractionCreateSchema = external_exports.object({\n threadId: external_exports.string().min(1),\n turnId: external_exports.string().min(1),\n providerId: external_exports.string().min(1),\n providerThreadId: external_exports.string().min(1),\n providerRequestId: external_exports.string().min(1),\n payload: pendingInteractionPayloadSchema\n });\n var pendingInteractionSchema = external_exports.object({\n id: external_exports.string().min(1),\n threadId: external_exports.string().min(1),\n turnId: external_exports.string().min(1),\n providerId: external_exports.string().min(1),\n providerThreadId: external_exports.string().min(1),\n providerRequestId: external_exports.string().min(1),\n status: pendingInteractionStatusSchema,\n payload: pendingInteractionPayloadSchema,\n resolution: pendingInteractionResolutionSchema.nullable(),\n statusReason: external_exports.string().nullable(),\n createdAt: external_exports.number().int().nonnegative(),\n resolvedAt: external_exports.number().int().nonnegative().nullable()\n });\n\n // ../domain/src/provider-types.ts\n var modelReasoningEffortSchema = external_exports.object({\n reasoningEffort: reasoningLevelSchema,\n description: external_exports.string()\n });\n var availableModelSchema = external_exports.object({\n id: external_exports.string(),\n model: external_exports.string(),\n displayName: external_exports.string(),\n description: external_exports.string(),\n supportedReasoningEfforts: external_exports.array(modelReasoningEffortSchema),\n defaultReasoningEffort: reasoningLevelSchema,\n isDefault: external_exports.boolean()\n });\n var providerCapabilitiesSchema = external_exports.object({\n supportsArchive: external_exports.boolean(),\n supportsRename: external_exports.boolean(),\n supportsServiceTier: external_exports.boolean(),\n supportsUserQuestion: external_exports.boolean(),\n supportedPermissionModes: external_exports.array(permissionModeSchema).min(1)\n });\n var providerInfoSchema = external_exports.object({\n id: external_exports.string(),\n displayName: external_exports.string(),\n capabilities: providerCapabilitiesSchema,\n available: external_exports.boolean()\n });\n var toolCallOutputItemSchema = external_exports.discriminatedUnion(\"type\", [\n external_exports.object({\n type: external_exports.literal(\"inputText\"),\n text: external_exports.string()\n }),\n external_exports.object({\n type: external_exports.literal(\"inputImage\"),\n imageUrl: external_exports.string()\n })\n ]);\n var toolCallRequestSchema = external_exports.object({\n requestId: external_exports.union([external_exports.string().min(1), external_exports.number()]),\n threadId: external_exports.string().min(1),\n providerThreadId: external_exports.string().min(1),\n turnId: external_exports.string().min(1),\n callId: external_exports.string().min(1),\n tool: external_exports.string().min(1),\n arguments: external_exports.unknown().optional()\n });\n var toolCallResponseSchema = external_exports.object({\n contentItems: external_exports.array(toolCallOutputItemSchema),\n success: external_exports.boolean()\n });\n var messageUserToolArgumentsSchema = external_exports.object({\n text: external_exports.string().trim().min(1).optional(),\n message: external_exports.string().trim().min(1).optional()\n }).refine(\n (value) => value.text !== void 0 || value.message !== void 0,\n \"message_user requires text\"\n ).transform((value) => ({\n text: value.text ?? value.message ?? \"\"\n }));\n var dynamicToolSchema = external_exports.object({\n name: external_exports.string(),\n description: external_exports.string(),\n inputSchema: external_exports.unknown()\n });\n\n // ../domain/src/environment.ts\n var environmentStatusValues = [\n \"provisioning\",\n \"ready\",\n \"error\",\n \"destroying\",\n \"destroyed\"\n ];\n var environmentStatusSchema = external_exports.enum(environmentStatusValues);\n var environmentCleanupModeValues = [\"safe\"];\n var environmentCleanupModeSchema = external_exports.enum(\n environmentCleanupModeValues\n );\n var WORKSPACE_PROVISION_TYPES = [\n \"unmanaged\",\n \"managed-worktree\",\n \"personal\"\n ];\n var workspaceProvisionTypeSchema = external_exports.enum(WORKSPACE_PROVISION_TYPES);\n var environmentWorkspaceDisplayKindValues = [\n \"managed-worktree\",\n \"unmanaged-worktree\",\n \"other\"\n ];\n var environmentWorkspaceDisplayKindSchema = external_exports.enum(\n environmentWorkspaceDisplayKindValues\n );\n var discoveredWorkspacePropertiesSchema = external_exports.object({\n path: external_exports.string().min(1),\n isGitRepo: external_exports.boolean(),\n isWorktree: external_exports.boolean(),\n branchName: external_exports.string().nullable(),\n defaultBranch: external_exports.string().nullable()\n });\n var environmentSchema = external_exports.object({\n id: external_exports.string(),\n projectId: external_exports.string(),\n hostId: external_exports.string(),\n path: external_exports.string().nullable(),\n managed: external_exports.boolean(),\n isGitRepo: external_exports.boolean(),\n isWorktree: external_exports.boolean(),\n workspaceProvisionType: workspaceProvisionTypeSchema,\n branchName: external_exports.string().nullable(),\n baseBranch: external_exports.string().nullable(),\n defaultBranch: external_exports.string().nullable(),\n mergeBaseBranch: external_exports.string().nullable(),\n cleanupRequestedAt: external_exports.number().nullable(),\n cleanupMode: environmentCleanupModeSchema.nullable(),\n status: environmentStatusSchema,\n createdAt: external_exports.number(),\n updatedAt: external_exports.number()\n });\n\n // ../domain/src/protocol-ids.ts\n var hostDaemonProducerEventIdSchema = external_exports.string().regex(/^hdevt_[23456789abcdefghijkmnpqrstuvwxyz]{20}$/u);\n var clientTurnRequestIdSchema = external_exports.string().regex(/^creq_[23456789abcdefghijkmnpqrstuvwxyz]{10}$/u);\n\n // ../domain/src/json-value.ts\n var jsonValueSchema = external_exports.lazy(\n () => external_exports.union([\n external_exports.string(),\n external_exports.number(),\n external_exports.boolean(),\n external_exports.null(),\n external_exports.array(jsonValueSchema),\n external_exports.record(external_exports.string(), jsonValueSchema)\n ])\n );\n var jsonObjectSchema = external_exports.record(\n external_exports.string(),\n jsonValueSchema\n );\n\n // ../domain/src/thread-event-scope.ts\n var threadEventScopeKindValues = [\"thread\", \"turn\"];\n var threadEventScopeKindSchema = external_exports.enum(threadEventScopeKindValues);\n var threadEventScopeSchema = external_exports.discriminatedUnion(\"kind\", [\n external_exports.object({ kind: external_exports.literal(\"thread\") }),\n external_exports.object({ kind: external_exports.literal(\"turn\"), turnId: external_exports.string().min(1) })\n ]);\n var threadEventScopePolicyValues = [\n \"thread\",\n \"turn\",\n \"thread-or-turn\"\n ];\n var threadEventScopePolicySchema = external_exports.enum(\n threadEventScopePolicyValues\n );\n var threadEventScopeDefinitionByType = {\n \"thread/started\": {\n policy: \"thread\",\n rationale: \"Thread lifecycle event; it creates the thread timeline itself.\"\n },\n \"thread/identity\": {\n policy: \"thread\",\n rationale: \"Thread metadata event; it identifies the provider thread outside turn chronology.\"\n },\n \"turn/started\": { policy: \"turn\" },\n \"turn/completed\": { policy: \"turn\" },\n \"turn/input/accepted\": { policy: \"turn\" },\n \"thread/name/updated\": {\n policy: \"thread\",\n rationale: \"Thread metadata event; names are not part of a specific turn transcript.\"\n },\n \"thread/compacted\": { policy: \"turn\" },\n \"item/started\": { policy: \"turn\" },\n \"item/completed\": { policy: \"turn\" },\n \"item/agentMessage/delta\": { policy: \"turn\" },\n \"item/commandExecution/outputDelta\": { policy: \"turn\" },\n \"item/fileChange/outputDelta\": { policy: \"turn\" },\n \"item/reasoning/summaryTextDelta\": { policy: \"turn\" },\n \"item/reasoning/textDelta\": { policy: \"turn\" },\n \"item/plan/delta\": { policy: \"turn\" },\n \"item/mcpToolCall/progress\": { policy: \"turn\" },\n \"item/toolCall/progress\": { policy: \"turn\" },\n \"item/backgroundTask/progress\": {\n policy: \"thread\",\n rationale: \"Background tasks outlive their spawning turn; thread scope keeps turn windows sequence-contiguous (late progress must not interleave into later turns' ranges).\"\n },\n \"item/backgroundTask/completed\": {\n policy: \"thread\",\n rationale: \"Terminal task state can arrive turns after the spawning turn completed; thread scope avoids appending into a closed turn's sequence range.\"\n },\n \"thread/tokenUsage/updated\": { policy: \"turn\" },\n \"thread/contextWindowUsage/updated\": { policy: \"turn\" },\n \"turn/plan/updated\": { policy: \"turn\" },\n \"turn/diff/updated\": { policy: \"turn\" },\n \"provider/error\": {\n policy: \"thread-or-turn\",\n rationale: \"Provider diagnostics use thread scope for provider setup/session failures; in-turn failures use turn scope.\"\n },\n \"provider/warning\": {\n policy: \"thread-or-turn\",\n rationale: \"Provider warnings use thread scope for config, deprecation, or global notices; turn-specific warnings use turn scope.\"\n },\n \"provider/unhandled\": {\n policy: \"thread-or-turn\",\n rationale: \"Unhandled provider events use thread scope only when no active turn context exists; in-turn unknown events use turn scope.\"\n },\n \"client/thread/start\": {\n policy: \"thread\",\n rationale: \"Outbound client lifecycle event; it requests thread creation before any turn exists.\"\n },\n \"client/turn/requested\": {\n policy: \"thread\",\n rationale: \"Outbound client lifecycle event; it records the request before provider turn acceptance.\"\n },\n \"client/turn/start\": {\n policy: \"thread\",\n rationale: \"Outbound client lifecycle event; it records the start request before provider turn acceptance.\"\n },\n \"system/error\": {\n policy: \"thread-or-turn\",\n rationale: \"System errors use thread scope for app, daemon, or session failures outside a turn; turn failures use turn scope.\"\n },\n \"system/manager/user_message\": {\n policy: \"thread-or-turn\",\n rationale: \"Manager messages can be thread-scoped for general manager updates or turn-scoped for in-turn updates.\"\n },\n \"system/thread/interrupted\": {\n policy: \"thread\",\n rationale: \"Thread stop lifecycle event; it represents user interruption of the whole running thread.\"\n },\n \"system/operation\": {\n policy: \"thread\",\n rationale: \"Thread-management operation event; ownership and lifecycle operations are not turn transcript content.\"\n },\n \"system/permissionGrant/lifecycle\": { policy: \"turn\" },\n \"system/userQuestion/lifecycle\": { policy: \"turn\" },\n \"system/thread-provisioning\": {\n policy: \"thread\",\n rationale: \"Workspace provisioning lifecycle event; environment setup belongs to the thread, not a turn.\"\n },\n \"system/provider-turn-watchdog\": {\n policy: \"thread\",\n rationale: \"Provider turn watchdog diagnostics describe server lifecycle ownership for the whole thread.\"\n }\n };\n function getThreadEventScopePolicyDefinitionEntries() {\n return Object.entries(threadEventScopeDefinitionByType).map(\n ([type, definition]) => ({\n type,\n definition\n })\n );\n }\n function getThreadEventTypesForScopePolicy(policy) {\n return getThreadEventScopePolicyDefinitionEntries().filter((entry) => entry.definition.policy === policy).map((entry) => entry.type);\n }\n function buildThreadEventScopePolicyByType() {\n const policies = {};\n for (const entry of getThreadEventScopePolicyDefinitionEntries()) {\n policies[entry.type] = entry.definition.policy;\n }\n return policies;\n }\n function buildThreadScopeRationaleByType() {\n const rationales = {};\n for (const entry of getThreadEventScopePolicyDefinitionEntries()) {\n if (entry.definition.rationale) {\n rationales[entry.type] = entry.definition.rationale;\n }\n }\n return rationales;\n }\n var turnOnlyThreadEventTypes = getThreadEventTypesForScopePolicy(\"turn\");\n var threadOnlyThreadEventTypes = getThreadEventTypesForScopePolicy(\"thread\");\n var threadOrTurnThreadEventTypes = getThreadEventTypesForScopePolicy(\"thread-or-turn\");\n var threadEventScopePolicyByType = buildThreadEventScopePolicyByType();\n var threadScopeRationaleByType = buildThreadScopeRationaleByType();\n function validateThreadEventScope(args) {\n const policy = threadEventScopePolicyByType[args.type];\n if (policy === \"thread-or-turn\") {\n return { valid: true };\n }\n if (policy !== args.scope.kind) {\n return {\n valid: false,\n message: `${args.type} requires ${policy} scope but received ${args.scope.kind} scope`\n };\n }\n return { valid: true };\n }\n\n // ../domain/src/provider-turn-watchdog.ts\n var providerTurnWatchdogReasonValues = [\"provider-turn-idle\"];\n var providerTurnWatchdogReasonSchema = external_exports.enum(\n providerTurnWatchdogReasonValues\n );\n var providerTurnWatchdogActivityEventTypeValues = [\n \"turn/started\",\n \"turn/input/accepted\",\n \"item/started\",\n \"item/completed\",\n \"item/agentMessage/delta\",\n \"item/commandExecution/outputDelta\",\n \"item/fileChange/outputDelta\",\n \"item/reasoning/summaryTextDelta\",\n \"item/reasoning/textDelta\",\n \"item/plan/delta\",\n \"item/mcpToolCall/progress\",\n \"item/toolCall/progress\",\n \"item/backgroundTask/progress\",\n \"item/backgroundTask/completed\",\n \"turn/plan/updated\",\n \"turn/diff/updated\",\n \"provider/error\",\n \"provider/warning\"\n ];\n var providerTurnWatchdogActivityEventTypeSchema = external_exports.enum(\n providerTurnWatchdogActivityEventTypeValues\n );\n var providerTurnWatchdogThreadScopedActivityEventTypeValues = providerTurnWatchdogActivityEventTypeValues.filter(\n (eventType) => threadEventScopePolicyByType[eventType] === \"thread\"\n );\n var systemProviderTurnWatchdogEventDataSchema = external_exports.object({\n reason: providerTurnWatchdogReasonSchema,\n thresholdMs: external_exports.number().int().positive(),\n elapsedMs: external_exports.number().int().nonnegative(),\n activeTurnId: external_exports.string().min(1),\n activeTurnStartedAt: external_exports.number().int().nonnegative(),\n lastActivityEventSequence: external_exports.number().int().positive(),\n /**\n * Diagnostic label only (the UI interpolates it verbatim). A plain string \u2014\n * not the activity enum \u2014 so editing the activity list never makes\n * previously persisted watchdog events unparseable.\n */\n lastActivityEventType: external_exports.string().min(1),\n lastActivityEventAt: external_exports.number().int().nonnegative(),\n providerId: external_exports.string().min(1),\n providerThreadId: external_exports.string().min(1).nullable(),\n firedAt: external_exports.number().int().nonnegative()\n });\n\n // ../domain/src/thread-events.ts\n var systemEventTypeValues = [\n \"client/thread/start\",\n \"client/turn/requested\",\n \"client/turn/start\",\n \"system/error\",\n \"system/manager/user_message\",\n \"system/thread/interrupted\",\n \"system/operation\",\n \"system/permissionGrant/lifecycle\",\n \"system/userQuestion/lifecycle\",\n \"system/thread-provisioning\",\n \"system/provider-turn-watchdog\"\n ];\n var systemEventTypeSchema = external_exports.enum(systemEventTypeValues);\n var threadTurnInitiatorValues = [\"user\", \"agent\", \"system\"];\n var threadTurnInitiatorSchema = external_exports.enum(threadTurnInitiatorValues);\n var threadProvisioningReasonValues = [\n \"thread-created\",\n \"boot-created-thread\",\n \"tell-after-provisioning-failure\",\n \"tell-after-missing-environment-attachment\",\n \"resume-missing-provider-thread\"\n ];\n var threadProvisioningReasonSchema = external_exports.enum(\n threadProvisioningReasonValues\n );\n var threadEnvironmentStartReasonValues = [\n ...threadProvisioningReasonValues,\n \"boot-active-resume\",\n \"resume-existing-provider-session\"\n ];\n var threadEnvironmentStartReasonSchema = external_exports.enum(\n threadEnvironmentStartReasonValues\n );\n var turnRequestOptionsSchema = resolvedThreadExecutionOptionsSchema;\n var turnRequestTargetSchema = external_exports.discriminatedUnion(\"kind\", [\n external_exports.object({ kind: external_exports.literal(\"thread-start\") }),\n external_exports.object({ kind: external_exports.literal(\"new-turn\") }),\n external_exports.object({\n kind: external_exports.literal(\"auto\"),\n expectedTurnId: external_exports.string().nullable()\n }),\n external_exports.object({\n kind: external_exports.literal(\"steer\"),\n expectedTurnId: external_exports.string().nullable()\n })\n ]);\n var clientTurnLifecycleEventDataSchema = external_exports.object({\n direction: external_exports.literal(\"outbound\"),\n source: external_exports.enum([\"spawn\", \"tell\"]),\n initiator: threadTurnInitiatorSchema,\n request: external_exports.object({\n method: external_exports.enum([\"thread/start\", \"turn/start\"]),\n params: external_exports.record(external_exports.string(), external_exports.unknown())\n })\n });\n var turnRequestEventDataSchema = external_exports.object({\n direction: external_exports.literal(\"outbound\"),\n requestId: clientTurnRequestIdSchema,\n source: external_exports.enum([\"spawn\", \"tell\"]),\n initiator: threadTurnInitiatorSchema,\n // Non-null only when initiator === \"agent\". The invariant is enforced by\n // writer typings rather than a schema refine so legacy persisted events\n // (initiator: \"agent\", senderThreadId: null from before the field\n // existed) still parse \u2014 the stored variant defaults both fields.\n senderThreadId: external_exports.string().nullable(),\n input: external_exports.array(promptInputSchema),\n target: turnRequestTargetSchema,\n request: external_exports.object({\n method: external_exports.enum([\"thread/start\", \"turn/start\"]),\n params: external_exports.record(external_exports.string(), external_exports.unknown())\n }),\n execution: turnRequestOptionsSchema\n });\n var systemErrorEventDataSchema = external_exports.object({\n code: external_exports.string().optional(),\n message: external_exports.string(),\n detail: external_exports.string().optional(),\n reconnectAttempt: external_exports.number().int().positive().optional(),\n reconnectTotal: external_exports.number().int().positive().optional()\n }).superRefine((value, ctx) => {\n const hasReconnectAttempt = value.reconnectAttempt !== void 0;\n const hasReconnectTotal = value.reconnectTotal !== void 0;\n if (hasReconnectAttempt !== hasReconnectTotal) {\n ctx.addIssue({\n code: external_exports.ZodIssueCode.custom,\n message: \"system/error reconnectAttempt and reconnectTotal must be provided together\"\n });\n return;\n }\n if (value.reconnectAttempt !== void 0 && value.reconnectTotal !== void 0 && value.reconnectAttempt > value.reconnectTotal) {\n ctx.addIssue({\n code: external_exports.ZodIssueCode.custom,\n message: \"system/error reconnectAttempt cannot be greater than reconnectTotal\"\n });\n }\n });\n var ownershipChangeOperationActionValues = [\n \"assign\",\n \"release\",\n \"transfer\"\n ];\n var ownershipChangeOperationActionSchema = external_exports.enum(\n ownershipChangeOperationActionValues\n );\n var ownershipChangeOperationMetadataSchema = external_exports.object({\n action: ownershipChangeOperationActionSchema,\n nextParentThreadId: external_exports.string().nullable(),\n nextParentThreadTitle: external_exports.string().nullable(),\n previousParentThreadId: external_exports.string().nullable(),\n previousParentThreadTitle: external_exports.string().nullable()\n });\n var systemOperationEventDataSchema = external_exports.object({\n operation: external_exports.string(),\n status: external_exports.string(),\n message: external_exports.string(),\n operationId: external_exports.string(),\n metadata: external_exports.record(external_exports.string(), jsonValueSchema).optional()\n });\n var systemPermissionGrantLifecycleEventDataSchema = external_exports.object({\n interactionId: external_exports.string(),\n providerId: external_exports.string(),\n providerRequestId: external_exports.string(),\n status: pendingInteractionStatusSchema,\n resolution: approvalPendingInteractionResolutionSchema.nullable().default(null),\n statusReason: external_exports.string().nullable().default(null),\n subject: pendingInteractionPermissionGrantApprovalSubjectSchema\n });\n var systemUserQuestionLifecycleEventDataSchema = external_exports.object({\n interactionId: external_exports.string(),\n providerId: external_exports.string(),\n providerRequestId: external_exports.string(),\n status: pendingInteractionStatusSchema,\n resolution: userQuestionPendingInteractionResolutionSchema.nullable().default(null),\n statusReason: external_exports.string().nullable().default(null),\n payload: userQuestionPendingInteractionPayloadSchema\n });\n var systemThreadInterruptedReasonValues = [\n \"manual-stop\",\n \"host-daemon-restarted\",\n \"provider-turn-idle\"\n ];\n var systemThreadInterruptedReasonSchema = external_exports.enum(\n systemThreadInterruptedReasonValues\n );\n var systemThreadInterruptedEventDataSchema = external_exports.object({\n reason: systemThreadInterruptedReasonSchema\n });\n var provisioningTranscriptEntrySchema = external_exports.object({\n type: external_exports.enum([\"step\", \"output\"]),\n key: external_exports.string(),\n text: external_exports.string(),\n startedAt: external_exports.number().optional(),\n status: external_exports.enum([\"started\", \"completed\", \"failed\"]).optional(),\n metadata: external_exports.record(external_exports.string(), external_exports.unknown()).optional()\n });\n var systemThreadProvisioningStatusValues = [\n \"active\",\n \"completed\",\n \"failed\"\n ];\n var systemThreadProvisioningStatusSchema = external_exports.enum(\n systemThreadProvisioningStatusValues\n );\n var systemThreadProvisioningEventDataSchema = external_exports.object({\n provisioningId: external_exports.string(),\n status: systemThreadProvisioningStatusSchema,\n environmentId: external_exports.string(),\n entries: external_exports.array(provisioningTranscriptEntrySchema)\n });\n var systemManagerUserMessageEventDataSchema = external_exports.object({\n text: external_exports.string(),\n toolCallId: external_exports.string().optional(),\n turnId: external_exports.string().optional()\n });\n var turnLifecycleEventDataSchema = external_exports.object({\n turnId: external_exports.string().optional(),\n input: external_exports.array(promptInputSchema).optional()\n });\n\n // ../domain/src/background-task.ts\n var backgroundTaskStatusValues = [\n \"pending\",\n \"running\",\n \"paused\",\n \"completed\",\n \"failed\",\n \"killed\",\n \"stopped\"\n ];\n var backgroundTaskStatusSchema = external_exports.enum(backgroundTaskStatusValues);\n var workflowAgentStateValues = [\n \"queued\",\n \"running\",\n \"done\",\n \"failed\",\n \"skipped\"\n ];\n var workflowAgentStateSchema = external_exports.enum(workflowAgentStateValues);\n var workflowAgentSnapshotSchema = external_exports.object({\n /** 1-based agent counter; the stable identity for fold/replace semantics. */\n index: external_exports.number().int().positive(),\n label: external_exports.string(),\n state: workflowAgentStateSchema,\n model: external_exports.string(),\n attempt: external_exports.number().int().positive(),\n cached: external_exports.boolean(),\n lastProgressAt: external_exports.number(),\n phaseIndex: external_exports.number().int().positive().optional(),\n phaseTitle: external_exports.string().optional(),\n agentType: external_exports.string().optional(),\n isolation: external_exports.string().optional(),\n queuedAt: external_exports.number().optional(),\n startedAt: external_exports.number().optional(),\n lastToolName: external_exports.string().optional(),\n lastToolSummary: external_exports.string().optional(),\n promptPreview: external_exports.string().optional(),\n resultPreview: external_exports.string().optional(),\n error: external_exports.string().optional(),\n tokens: external_exports.number().optional(),\n toolCalls: external_exports.number().optional(),\n durationMs: external_exports.number().optional()\n });\n var workflowPhaseSnapshotSchema = external_exports.object({\n /** 1-based phase counter; meta.phases are seeded before any agent runs. */\n index: external_exports.number().int().positive(),\n title: external_exports.string(),\n /** \"child\" marks a nested workflow() sub-run group. */\n kind: external_exports.string().optional()\n });\n var workflowProgressSnapshotSchema = external_exports.object({\n phases: external_exports.array(workflowPhaseSnapshotSchema),\n agents: external_exports.array(workflowAgentSnapshotSchema)\n });\n var backgroundTaskUsageSchema = external_exports.object({\n totalTokens: external_exports.number(),\n toolUses: external_exports.number(),\n durationMs: external_exports.number()\n });\n\n // ../domain/src/provider-event.ts\n var threadEventItemStatusSchema = external_exports.enum([\n \"pending\",\n \"completed\",\n \"failed\",\n \"interrupted\"\n ]);\n var threadEventItemApprovalStatusSchema = external_exports.enum([\"waiting_for_approval\", \"denied\"]).nullable();\n var threadEventTurnStatusSchema = external_exports.enum([\n \"completed\",\n \"failed\",\n \"interrupted\"\n ]);\n var providerErrorCategoryValues = [\n \"active-turn-not-steerable\",\n \"bad-request\",\n \"connection-failed\",\n \"context-window-exceeded\",\n \"billing\",\n \"budget-exceeded\",\n \"internal\",\n \"max-output-tokens\",\n \"max-turns\",\n \"overloaded\",\n \"policy\",\n \"rate-limit\",\n \"sandbox\",\n \"stream-disconnected\",\n \"structured-output-retries\",\n \"thread-rollback-failed\",\n \"too-many-failed-attempts\",\n \"unauthorized\",\n \"unknown\"\n ];\n var providerErrorCategorySchema = external_exports.enum(providerErrorCategoryValues);\n var providerErrorInfoSchema = external_exports.object({\n category: providerErrorCategorySchema,\n providerCode: external_exports.string().nullable(),\n httpStatusCode: external_exports.number().nullable()\n });\n var threadEventFileChangeKindSchema = external_exports.enum([\n \"add\",\n \"delete\",\n \"update\"\n ]);\n var threadEventFileChangeSchema = external_exports.object({\n path: external_exports.string(),\n kind: threadEventFileChangeKindSchema,\n movePath: external_exports.string().optional(),\n diff: external_exports.string().optional()\n });\n var threadEventPlanStepStatusSchema = external_exports.enum([\n \"pending\",\n \"active\",\n \"completed\",\n \"failed\"\n ]);\n var threadEventPlanStepSchema = external_exports.object({\n step: external_exports.string(),\n status: threadEventPlanStepStatusSchema.optional()\n });\n var threadEventWebSearchItemSchema = external_exports.object({\n type: external_exports.literal(\"webSearch\"),\n id: external_exports.string(),\n queries: external_exports.array(external_exports.string()).min(1),\n resultText: external_exports.string().nullable(),\n parentToolCallId: external_exports.string().optional()\n });\n var threadEventWebFetchItemSchema = external_exports.object({\n type: external_exports.literal(\"webFetch\"),\n id: external_exports.string(),\n url: external_exports.string(),\n prompt: external_exports.string().nullable(),\n pattern: external_exports.string().nullable(),\n resultText: external_exports.string().nullable(),\n parentToolCallId: external_exports.string().optional()\n });\n var threadEventImageViewItemSchema = external_exports.object({\n type: external_exports.literal(\"imageView\"),\n id: external_exports.string(),\n path: external_exports.string(),\n parentToolCallId: external_exports.string().optional()\n });\n var threadEventTextTruncationSchema = external_exports.object({\n originalLength: external_exports.number(),\n retainedHeadLength: external_exports.number(),\n retainedTailLength: external_exports.number(),\n truncatedAt: external_exports.number()\n });\n var threadEventItemTruncationSchema = external_exports.object({\n aggregatedOutput: threadEventTextTruncationSchema.optional(),\n result: threadEventTextTruncationSchema.optional(),\n resultText: threadEventTextTruncationSchema.optional()\n });\n var threadEventUserContentSchema = external_exports.discriminatedUnion(\"type\", [\n external_exports.object({ type: external_exports.literal(\"text\"), text: external_exports.string() }),\n external_exports.object({ type: external_exports.literal(\"image\"), url: external_exports.string() }),\n external_exports.object({ type: external_exports.literal(\"localImage\"), path: external_exports.string() }),\n external_exports.object({ type: external_exports.literal(\"localFile\"), path: external_exports.string() })\n ]);\n var threadEventTokenUsageBreakdownSchema = external_exports.object({\n totalTokens: external_exports.number(),\n inputTokens: external_exports.number(),\n cachedInputTokens: external_exports.number(),\n outputTokens: external_exports.number(),\n reasoningOutputTokens: external_exports.number()\n });\n var threadEventContextWindowUsageSchema = external_exports.object({\n usedTokens: external_exports.number().nullable(),\n modelContextWindow: external_exports.number().nullable(),\n estimated: external_exports.boolean()\n });\n var threadEventTokenUsageSchema = external_exports.object({\n total: threadEventTokenUsageBreakdownSchema,\n last: threadEventTokenUsageBreakdownSchema,\n modelContextWindow: external_exports.number().nullable()\n });\n var threadEventWarningCategorySchema = external_exports.enum([\n \"deprecation\",\n \"config\",\n \"general\"\n ]);\n var providerRawEventSchema = external_exports.object({\n jsonrpc: external_exports.literal(\"2.0\"),\n id: external_exports.union([external_exports.string(), external_exports.number()]).optional(),\n method: external_exports.string(),\n params: jsonValueSchema.optional()\n });\n var providerUnhandledEventSchema = external_exports.object({\n type: external_exports.literal(\"provider/unhandled\"),\n threadId: external_exports.string(),\n providerThreadId: external_exports.string(),\n providerId: external_exports.string(),\n rawType: external_exports.string(),\n rawEvent: providerRawEventSchema,\n parentToolCallId: external_exports.string().optional()\n });\n var toolCallProgressEventSchema = external_exports.object({\n type: external_exports.literal(\"item/toolCall/progress\"),\n threadId: external_exports.string(),\n providerThreadId: external_exports.string(),\n itemId: external_exports.string(),\n message: external_exports.string().optional(),\n parentToolCallId: external_exports.string().optional()\n });\n var threadEventBackgroundTaskItemSchema = external_exports.object({\n type: external_exports.literal(\"backgroundTask\"),\n id: external_exports.string(),\n /** Raw SDK task discriminant (e.g. \"local_workflow\"); \"unknown\" when the provider omitted it. */\n taskType: external_exports.string(),\n description: external_exports.string(),\n status: threadEventItemStatusSchema,\n taskStatus: backgroundTaskStatusSchema,\n /** Ambient/housekeeping task; consumers hide it from the inline transcript. */\n skipTranscript: external_exports.boolean(),\n /** meta.name of the workflow script; only present for workflow tasks. */\n workflowName: external_exports.string().optional(),\n /** Merged workflow tree; absent until the provider reports progress records. */\n workflow: workflowProgressSnapshotSchema.optional(),\n /** Absent until the provider reports usage. */\n usage: backgroundTaskUsageSchema.optional(),\n /** Terminal summary from the provider; absent while the task runs. */\n summary: external_exports.string().optional(),\n error: external_exports.string().optional(),\n outputFile: external_exports.string().optional(),\n parentToolCallId: external_exports.string().optional()\n });\n var threadEventItemSchema = external_exports.discriminatedUnion(\"type\", [\n external_exports.object({\n type: external_exports.literal(\"userMessage\"),\n id: external_exports.string(),\n content: external_exports.array(threadEventUserContentSchema),\n clientRequestId: clientTurnRequestIdSchema.optional(),\n parentToolCallId: external_exports.string().optional()\n }).strict(),\n external_exports.object({\n type: external_exports.literal(\"agentMessage\"),\n id: external_exports.string(),\n text: external_exports.string(),\n parentToolCallId: external_exports.string().optional()\n }),\n external_exports.object({\n type: external_exports.literal(\"commandExecution\"),\n id: external_exports.string(),\n command: external_exports.string(),\n cwd: external_exports.string(),\n status: threadEventItemStatusSchema,\n approvalStatus: threadEventItemApprovalStatusSchema,\n /**\n * Omitted when the process produced no stdout/stderr. Adapters should omit\n * this field instead of emitting an empty string placeholder.\n */\n aggregatedOutput: external_exports.string().optional(),\n exitCode: external_exports.number().optional(),\n durationMs: external_exports.number().optional(),\n truncation: threadEventItemTruncationSchema.optional(),\n parentToolCallId: external_exports.string().optional()\n }),\n external_exports.object({\n type: external_exports.literal(\"fileChange\"),\n id: external_exports.string(),\n changes: external_exports.array(threadEventFileChangeSchema),\n status: threadEventItemStatusSchema,\n approvalStatus: threadEventItemApprovalStatusSchema,\n parentToolCallId: external_exports.string().optional()\n }),\n threadEventWebSearchItemSchema,\n threadEventWebFetchItemSchema,\n threadEventImageViewItemSchema,\n external_exports.object({\n type: external_exports.literal(\"toolCall\"),\n id: external_exports.string(),\n server: external_exports.string().optional(),\n tool: external_exports.string(),\n arguments: external_exports.record(external_exports.string(), external_exports.unknown()).optional(),\n status: threadEventItemStatusSchema,\n result: external_exports.unknown().optional(),\n error: external_exports.string().optional(),\n durationMs: external_exports.number().optional(),\n truncation: threadEventItemTruncationSchema.optional(),\n parentToolCallId: external_exports.string().optional()\n }),\n external_exports.object({\n type: external_exports.literal(\"reasoning\"),\n id: external_exports.string(),\n summary: external_exports.array(external_exports.string()),\n content: external_exports.array(external_exports.string()),\n parentToolCallId: external_exports.string().optional()\n }),\n external_exports.object({\n type: external_exports.literal(\"plan\"),\n id: external_exports.string(),\n text: external_exports.string(),\n parentToolCallId: external_exports.string().optional()\n }),\n external_exports.object({\n type: external_exports.literal(\"contextCompaction\"),\n id: external_exports.string(),\n parentToolCallId: external_exports.string().optional()\n }),\n threadEventBackgroundTaskItemSchema\n ]);\n var unscopedProviderEventSchema = external_exports.discriminatedUnion(\"type\", [\n external_exports.object({\n type: external_exports.literal(\"thread/started\"),\n threadId: external_exports.string()\n }),\n external_exports.object({\n type: external_exports.literal(\"thread/identity\"),\n threadId: external_exports.string(),\n providerThreadId: external_exports.string()\n }),\n external_exports.object({\n type: external_exports.literal(\"turn/started\"),\n threadId: external_exports.string(),\n providerThreadId: external_exports.string()\n }),\n external_exports.object({\n type: external_exports.literal(\"turn/completed\"),\n threadId: external_exports.string(),\n // Server reconciliation can synthesize interrupted completions when the\n // original provider thread id was never persisted.\n providerThreadId: external_exports.string().nullable(),\n status: threadEventTurnStatusSchema,\n error: external_exports.object({ message: external_exports.string() }).optional()\n }),\n external_exports.object({\n type: external_exports.literal(\"turn/input/accepted\"),\n threadId: external_exports.string(),\n providerThreadId: external_exports.string(),\n clientRequestId: clientTurnRequestIdSchema,\n scope: threadEventScopeSchema\n }).strict(),\n external_exports.object({\n type: external_exports.literal(\"thread/name/updated\"),\n threadId: external_exports.string(),\n providerThreadId: external_exports.string(),\n threadName: external_exports.string()\n }),\n external_exports.object({\n type: external_exports.literal(\"thread/compacted\"),\n threadId: external_exports.string(),\n providerThreadId: external_exports.string()\n }),\n external_exports.object({\n type: external_exports.literal(\"item/started\"),\n threadId: external_exports.string(),\n providerThreadId: external_exports.string(),\n item: threadEventItemSchema\n }),\n external_exports.object({\n type: external_exports.literal(\"item/completed\"),\n threadId: external_exports.string(),\n providerThreadId: external_exports.string(),\n item: threadEventItemSchema\n }),\n external_exports.object({\n type: external_exports.literal(\"item/agentMessage/delta\"),\n threadId: external_exports.string(),\n providerThreadId: external_exports.string(),\n itemId: external_exports.string(),\n delta: external_exports.string(),\n parentToolCallId: external_exports.string().optional()\n }),\n external_exports.object({\n type: external_exports.literal(\"item/commandExecution/outputDelta\"),\n threadId: external_exports.string(),\n providerThreadId: external_exports.string(),\n itemId: external_exports.string(),\n delta: external_exports.string(),\n /**\n * When true, this delta replaces previously accumulated command output\n * instead of appending to it. Omission means the delta appends.\n */\n reset: external_exports.boolean().optional(),\n parentToolCallId: external_exports.string().optional()\n }),\n external_exports.object({\n type: external_exports.literal(\"item/fileChange/outputDelta\"),\n threadId: external_exports.string(),\n providerThreadId: external_exports.string(),\n itemId: external_exports.string(),\n delta: external_exports.string(),\n parentToolCallId: external_exports.string().optional()\n }),\n external_exports.object({\n type: external_exports.literal(\"item/reasoning/summaryTextDelta\"),\n threadId: external_exports.string(),\n providerThreadId: external_exports.string(),\n itemId: external_exports.string(),\n delta: external_exports.string(),\n parentToolCallId: external_exports.string().optional()\n }),\n external_exports.object({\n type: external_exports.literal(\"item/reasoning/textDelta\"),\n threadId: external_exports.string(),\n providerThreadId: external_exports.string(),\n itemId: external_exports.string(),\n delta: external_exports.string(),\n parentToolCallId: external_exports.string().optional()\n }),\n external_exports.object({\n type: external_exports.literal(\"item/plan/delta\"),\n threadId: external_exports.string(),\n providerThreadId: external_exports.string(),\n itemId: external_exports.string(),\n delta: external_exports.string(),\n parentToolCallId: external_exports.string().optional()\n }),\n external_exports.object({\n type: external_exports.literal(\"item/mcpToolCall/progress\"),\n threadId: external_exports.string(),\n providerThreadId: external_exports.string(),\n itemId: external_exports.string(),\n message: external_exports.string().optional(),\n parentToolCallId: external_exports.string().optional()\n }),\n toolCallProgressEventSchema,\n /**\n * Superseding state snapshot for an in-flight background task. Thread-scoped\n * (not turn-scoped) because tasks outlive their spawning turn: late events\n * must not interleave into later turns' sequence-contiguous windows. Each\n * progress event carries the full current item state; consumers replace, not\n * merge. The item is placed in the timeline by its turn-scoped item/started.\n */\n external_exports.object({\n type: external_exports.literal(\"item/backgroundTask/progress\"),\n threadId: external_exports.string(),\n providerThreadId: external_exports.string(),\n item: threadEventBackgroundTaskItemSchema\n }),\n /**\n * Terminal state for a background task, carrying the full final item\n * payload. Dedicated event (instead of the generic turn-scoped\n * item/completed) because it may arrive turns after the item/started.\n */\n external_exports.object({\n type: external_exports.literal(\"item/backgroundTask/completed\"),\n threadId: external_exports.string(),\n providerThreadId: external_exports.string(),\n item: threadEventBackgroundTaskItemSchema\n }),\n external_exports.object({\n type: external_exports.literal(\"thread/tokenUsage/updated\"),\n threadId: external_exports.string(),\n providerThreadId: external_exports.string(),\n tokenUsage: threadEventTokenUsageSchema\n }),\n external_exports.object({\n type: external_exports.literal(\"thread/contextWindowUsage/updated\"),\n threadId: external_exports.string(),\n providerThreadId: external_exports.string(),\n contextWindowUsage: threadEventContextWindowUsageSchema\n }),\n external_exports.object({\n type: external_exports.literal(\"turn/plan/updated\"),\n threadId: external_exports.string(),\n providerThreadId: external_exports.string(),\n plan: external_exports.array(threadEventPlanStepSchema),\n explanation: external_exports.string().optional()\n }),\n external_exports.object({\n type: external_exports.literal(\"turn/diff/updated\"),\n threadId: external_exports.string(),\n providerThreadId: external_exports.string(),\n diff: external_exports.string().optional()\n }),\n external_exports.object({\n type: external_exports.literal(\"provider/error\"),\n threadId: external_exports.string(),\n providerThreadId: external_exports.string(),\n message: external_exports.string(),\n detail: external_exports.string().optional(),\n willRetry: external_exports.boolean().optional(),\n errorInfo: providerErrorInfoSchema.optional()\n }),\n external_exports.object({\n type: external_exports.literal(\"provider/warning\"),\n threadId: external_exports.string(),\n providerThreadId: external_exports.string(),\n category: threadEventWarningCategorySchema,\n summary: external_exports.string().optional(),\n details: external_exports.string().optional()\n }),\n providerUnhandledEventSchema\n ]);\n var scopedEventDataSchema = external_exports.object({\n scope: threadEventScopeSchema\n });\n var providerEventSchema = unscopedProviderEventSchema.and(\n scopedEventDataSchema\n );\n var providerEventTypeValues = unscopedProviderEventSchema.options.map(\n (option) => option.shape.type.value\n );\n var unscopedSystemEventSchema = external_exports.union([\n external_exports.object({\n type: external_exports.literal(\"client/thread/start\"),\n threadId: external_exports.string()\n }).merge(clientTurnLifecycleEventDataSchema),\n external_exports.object({\n type: external_exports.literal(\"client/turn/requested\"),\n threadId: external_exports.string()\n }).merge(turnRequestEventDataSchema),\n external_exports.object({\n type: external_exports.literal(\"client/turn/start\"),\n threadId: external_exports.string()\n }).merge(clientTurnLifecycleEventDataSchema),\n external_exports.object({\n type: external_exports.literal(\"system/error\"),\n threadId: external_exports.string()\n }).merge(systemErrorEventDataSchema),\n external_exports.object({\n type: external_exports.literal(\"system/manager/user_message\"),\n threadId: external_exports.string()\n }).merge(systemManagerUserMessageEventDataSchema),\n external_exports.object({\n type: external_exports.literal(\"system/thread/interrupted\"),\n threadId: external_exports.string()\n }).merge(systemThreadInterruptedEventDataSchema),\n external_exports.object({\n type: external_exports.literal(\"system/operation\"),\n threadId: external_exports.string()\n }).merge(systemOperationEventDataSchema),\n external_exports.object({\n type: external_exports.literal(\"system/permissionGrant/lifecycle\"),\n threadId: external_exports.string()\n }).merge(systemPermissionGrantLifecycleEventDataSchema),\n external_exports.object({\n type: external_exports.literal(\"system/userQuestion/lifecycle\"),\n threadId: external_exports.string()\n }).merge(systemUserQuestionLifecycleEventDataSchema),\n external_exports.object({\n type: external_exports.literal(\"system/thread-provisioning\"),\n threadId: external_exports.string()\n }).merge(systemThreadProvisioningEventDataSchema),\n external_exports.object({\n type: external_exports.literal(\"system/provider-turn-watchdog\"),\n threadId: external_exports.string()\n }).merge(systemProviderTurnWatchdogEventDataSchema)\n ]);\n var systemEventSchema = unscopedSystemEventSchema.and(\n scopedEventDataSchema\n );\n var eventPropertyBagSchema = external_exports.record(external_exports.string(), external_exports.unknown());\n var legacyClientRequestKey = [\"clientRequest\", \"Sequence\"].join(\"\");\n var rejectLegacyClientRequestSequenceSchema = external_exports.unknown().superRefine((value, ctx) => {\n const eventResult = eventPropertyBagSchema.safeParse(value);\n if (!eventResult.success) {\n return;\n }\n if (Object.hasOwn(eventResult.data, legacyClientRequestKey)) {\n ctx.addIssue({\n code: external_exports.ZodIssueCode.custom,\n message: \"legacy request sequence field is no longer accepted\",\n path: [legacyClientRequestKey]\n });\n }\n const itemResult = eventPropertyBagSchema.safeParse(eventResult.data.item);\n if (itemResult.success && itemResult.data.type === \"userMessage\" && Object.hasOwn(itemResult.data, legacyClientRequestKey)) {\n ctx.addIssue({\n code: external_exports.ZodIssueCode.custom,\n message: \"legacy user-message request sequence field is no longer accepted\",\n path: [\"item\", legacyClientRequestKey]\n });\n }\n });\n var threadEventSchema = rejectLegacyClientRequestSequenceSchema.pipe(\n external_exports.union([providerEventSchema, systemEventSchema]).superRefine((event, ctx) => {\n const result = validateThreadEventScope({\n type: event.type,\n scope: event.scope\n });\n if (!result.valid) {\n ctx.addIssue({\n code: external_exports.ZodIssueCode.custom,\n message: result.message ?? \"Invalid thread event scope\",\n path: [\"scope\"]\n });\n return;\n }\n })\n );\n var threadEventTypeValues = [\n ...providerEventTypeValues,\n ...systemEventTypeValues\n ];\n var threadEventTypeSet = new Set(threadEventTypeValues);\n var threadEventTypeSchema = external_exports.string().refine(\n (value) => threadEventTypeSet.has(value),\n \"Invalid thread event type\"\n );\n\n // ../domain/src/lifecycle-operations.ts\n var lifecycleOperationStateValues = [\n \"requested\",\n \"queued\",\n \"completed\",\n \"failed\",\n \"cancelled\"\n ];\n var lifecycleOperationStateSchema = external_exports.enum(\n lifecycleOperationStateValues\n );\n var environmentOperationKindValues = [\n \"provision\",\n \"reprovision\",\n \"destroy\"\n ];\n var environmentOperationKindSchema = external_exports.enum(\n environmentOperationKindValues\n );\n var threadOperationKindValues = [\n \"provision\",\n \"start\",\n \"stop\"\n ];\n var threadOperationKindSchema = external_exports.enum(threadOperationKindValues);\n var threadProvisioningStageValues = [\n \"metadata-pending\",\n \"environment-pending\",\n \"environment-attached\",\n \"environment-provisioning\",\n \"workspace-ready\"\n ];\n var threadProvisioningStageSchema = external_exports.enum(\n threadProvisioningStageValues\n );\n var projectOperationKindValues = [\"delete\"];\n var projectOperationKindSchema = external_exports.enum(projectOperationKindValues);\n\n // ../domain/src/project.ts\n var PERSONAL_PROJECT_ID = \"proj_personal\";\n var projectKindValues = [\"standard\", \"personal\"];\n var projectKindSchema = external_exports.enum(projectKindValues);\n var projectSchema = external_exports.object({\n id: external_exports.string(),\n kind: projectKindSchema,\n name: external_exports.string(),\n createdAt: external_exports.number(),\n updatedAt: external_exports.number()\n });\n var projectSourceTypeValues = [\"local_path\"];\n var projectSourceTypeSchema = external_exports.enum(projectSourceTypeValues);\n var baseProjectSourceSchema = external_exports.object({\n id: external_exports.string(),\n projectId: external_exports.string(),\n isDefault: external_exports.boolean(),\n createdAt: external_exports.number(),\n updatedAt: external_exports.number()\n });\n var localPathProjectSourceSchema = baseProjectSourceSchema.extend({\n type: external_exports.literal(\"local_path\"),\n hostId: external_exports.string(),\n path: external_exports.string()\n });\n var projectSourceSchema = localPathProjectSourceSchema;\n\n // ../domain/src/project-path.ts\n var WINDOWS_DRIVE_ROOT_PATTERN = /^[A-Za-z]:(?:[\\\\/]+)?$/u;\n var WINDOWS_ABSOLUTE_PATH_PATTERN = /^[A-Za-z]:(?:[\\\\/]+)/u;\n var WINDOWS_UNC_PATH_PATTERN = /^\\\\\\\\[^\\\\/]+(?:[\\\\/]+)[^\\\\/]+/u;\n var INVALID_PROJECT_PATH_MESSAGE = \"Project path must be an absolute path.\";\n var PROJECT_PATH_ROOT_MESSAGE = \"Project path must point to a project directory, not the filesystem root.\";\n var UNSUPPORTED_NATIVE_WINDOWS_PROJECT_PATH_MESSAGE = \"Native Windows paths are not supported. Use a POSIX path like /home/me/repo or /mnt/c/Users/me/repo.\";\n function isNativeWindowsProjectPath(path) {\n const trimmedPath = path.trim();\n if (!trimmedPath) {\n return false;\n }\n return WINDOWS_DRIVE_ROOT_PATTERN.test(trimmedPath) || WINDOWS_ABSOLUTE_PATH_PATTERN.test(trimmedPath) || WINDOWS_UNC_PATH_PATTERN.test(trimmedPath);\n }\n function isAbsoluteProjectPath(path) {\n const trimmedPath = path.trim();\n if (!trimmedPath) {\n return false;\n }\n return trimmedPath.startsWith(\"/\");\n }\n function normalizeProjectPathInput(path) {\n const trimmedPath = path.trim();\n if (!trimmedPath) {\n return \"\";\n }\n if (trimmedPath === \"/\") {\n return trimmedPath;\n }\n return trimmedPath.replace(/\\/+$/u, \"\");\n }\n function getProjectPathValidationMessage(path) {\n const normalizedPath = normalizeProjectPathInput(path);\n if (!normalizedPath) {\n return INVALID_PROJECT_PATH_MESSAGE;\n }\n if (isNativeWindowsProjectPath(normalizedPath)) {\n return UNSUPPORTED_NATIVE_WINDOWS_PROJECT_PATH_MESSAGE;\n }\n if (!isAbsoluteProjectPath(normalizedPath)) {\n return INVALID_PROJECT_PATH_MESSAGE;\n }\n if (normalizedPath === \"/\") {\n return PROJECT_PATH_ROOT_MESSAGE;\n }\n return null;\n }\n\n // ../domain/src/host.ts\n var hostTypeValues = [\"persistent\"];\n var hostTypeSchema = external_exports.enum(hostTypeValues);\n var hostStatusValues = [\"connected\", \"disconnected\"];\n var hostStatusSchema = external_exports.enum(hostStatusValues);\n var hostSchema = external_exports.object({\n id: external_exports.string(),\n name: external_exports.string(),\n type: hostTypeSchema,\n status: hostStatusSchema,\n lastSeenAt: external_exports.number().nullable(),\n createdAt: external_exports.number(),\n updatedAt: external_exports.number()\n });\n\n // ../domain/src/thread-status.ts\n var threadStatusValues = [\n \"created\",\n \"provisioning\",\n \"idle\",\n \"active\",\n \"error\"\n ];\n var threadStatusSchema = external_exports.enum(threadStatusValues);\n\n // ../domain/src/thread.ts\n var threadRuntimeDisplayStatusValues = [\n ...threadStatusValues,\n \"host-reconnecting\",\n \"waiting-for-host\"\n ];\n var threadRuntimeDisplayStatusSchema = external_exports.enum(\n threadRuntimeDisplayStatusValues\n );\n var threadRuntimeStateSchema = external_exports.object({\n displayStatus: threadRuntimeDisplayStatusSchema,\n hostReconnectGraceExpiresAt: external_exports.number().nullable()\n });\n var threadTypeValues = [\"standard\", \"manager\"];\n var threadTypeSchema = external_exports.enum(threadTypeValues);\n var workspaceStateValues = [\n \"clean\",\n \"untracked\",\n \"dirty_uncommitted\",\n \"committed_unmerged\",\n \"dirty_and_committed_unmerged\"\n ];\n var workspaceStateSchema = external_exports.enum(workspaceStateValues);\n var workspaceFileStatusKindSchema = external_exports.enum([\n \"M\",\n \"A\",\n \"D\",\n \"R\",\n \"C\",\n \"U\",\n \"??\",\n /**\n * Fallback for git status letters we don't recognize. Kept distinct from\n * \"M\" so UI and consumers can surface the ambiguity rather than silently\n * mislabeling the change.\n */\n \"?\"\n ]);\n var workspaceFileStatusSchema = external_exports.object({\n path: external_exports.string(),\n status: workspaceFileStatusKindSchema,\n /**\n * Per-file line counts from `git diff --numstat`. Null when the count is\n * unknown \u2014 binary files (numstat reports `-`) and untracked files (numstat\n * does not include them).\n */\n insertions: external_exports.number().nullable(),\n deletions: external_exports.number().nullable()\n });\n var workspaceCommitSummarySchema = external_exports.object({\n sha: external_exports.string(),\n shortSha: external_exports.string(),\n subject: external_exports.string(),\n authorName: external_exports.string(),\n authoredAt: external_exports.number()\n });\n var workspaceChangeStatsSchema = external_exports.object({\n insertions: external_exports.number(),\n deletions: external_exports.number(),\n files: external_exports.array(workspaceFileStatusSchema)\n });\n var workspaceWorkingTreeSchema = workspaceChangeStatsSchema.extend({\n hasUncommittedChanges: external_exports.boolean(),\n state: workspaceStateSchema\n });\n var workspaceBranchSchema = external_exports.object({\n currentBranch: external_exports.string().nullable(),\n defaultBranch: external_exports.string()\n });\n var workspaceMergeBaseSchema = workspaceChangeStatsSchema.extend({\n mergeBaseBranch: external_exports.string(),\n baseRef: external_exports.string().nullable(),\n aheadCount: external_exports.number(),\n behindCount: external_exports.number(),\n hasCommittedUnmergedChanges: external_exports.boolean(),\n commits: external_exports.array(workspaceCommitSummarySchema)\n });\n var workspaceStatusSchema = external_exports.object({\n workingTree: workspaceWorkingTreeSchema,\n branch: workspaceBranchSchema,\n mergeBase: workspaceMergeBaseSchema.nullable()\n });\n var threadQueuedMessageSchema = external_exports.object({\n id: external_exports.string(),\n content: external_exports.array(promptInputSchema).min(1),\n model: external_exports.string().min(1),\n reasoningLevel: reasoningLevelSchema,\n permissionMode: permissionModeSchema,\n serviceTier: serviceTierSchema,\n createdAt: external_exports.number(),\n updatedAt: external_exports.number()\n });\n var threadSchema = external_exports.object({\n id: external_exports.string(),\n projectId: external_exports.string(),\n environmentId: external_exports.string().nullable(),\n automationId: external_exports.string().nullable(),\n providerId: external_exports.string(),\n type: threadTypeSchema,\n title: external_exports.string().nullable(),\n titleFallback: external_exports.string().nullable(),\n status: threadStatusSchema,\n parentThreadId: external_exports.string().nullable(),\n archivedAt: external_exports.number().nullable(),\n pinnedAt: external_exports.number().nullable(),\n stopRequestedAt: external_exports.number().nullable(),\n deletedAt: external_exports.number().nullable(),\n lastReadAt: external_exports.number().nullable(),\n latestAttentionAt: external_exports.number(),\n createdAt: external_exports.number(),\n updatedAt: external_exports.number()\n });\n var threadWithRuntimeSchema = threadSchema.extend({\n runtime: threadRuntimeStateSchema\n });\n var threadListEntrySchema = threadWithRuntimeSchema.extend({\n pinSortKey: external_exports.string().nullable(),\n hasPendingInteraction: external_exports.boolean(),\n environmentHostId: external_exports.string().nullable(),\n environmentBranchName: external_exports.string().nullable(),\n environmentWorkspaceDisplayKind: environmentWorkspaceDisplayKindSchema\n });\n\n // ../domain/src/thread-git-diff.ts\n var workspaceDiffTargetSchema = external_exports.discriminatedUnion(\"type\", [\n external_exports.object({\n type: external_exports.literal(\"uncommitted\")\n }),\n external_exports.object({\n type: external_exports.literal(\"branch_committed\"),\n mergeBaseBranch: external_exports.string().min(1)\n }),\n external_exports.object({\n type: external_exports.literal(\"all\"),\n mergeBaseBranch: external_exports.string().min(1)\n }),\n external_exports.object({\n type: external_exports.literal(\"commit\"),\n sha: external_exports.string().regex(/^[0-9a-f]{4,40}$/iu)\n })\n ]);\n var threadGitDiffResponseSchema = external_exports.object({\n diff: external_exports.string(),\n truncated: external_exports.boolean(),\n shortstat: external_exports.string(),\n files: external_exports.string(),\n /**\n * Resolved merge-base SHA for `branch_committed` / `all` targets \u2014 the\n * exact ref the diff was computed against. `null` for targets that don't\n * use a merge-base (`uncommitted`, `commit`), and also when no merge-base\n * exists (e.g. the branch has been removed locally). Callers fetching\n * per-file content for context expansion must pass this SHA as the\n * \"old side\" ref so the file content lines up with the diff's hunk\n * coordinates \u2014 passing the branch name reads from its current tip, which\n * may have diverged past the merge-base.\n */\n mergeBaseRef: external_exports.string().nullable()\n });\n\n // ../domain/src/stored-thread-event.ts\n var threadEventRowInputSchema = external_exports.object({\n id: external_exports.string(),\n scope: threadEventScopeSchema,\n threadId: external_exports.string(),\n seq: external_exports.number(),\n type: threadEventTypeSchema,\n data: external_exports.record(external_exports.string(), external_exports.unknown()),\n createdAt: external_exports.number()\n });\n var storedTurnRequestTypeSet = /* @__PURE__ */ new Set([\n \"client/turn/requested\"\n ]);\n var LEGACY_TURN_REQUEST_TARGET = {\n kind: \"new-turn\"\n };\n var storedTurnRequestEventDataSchema = turnRequestEventDataSchema.extend({\n senderThreadId: external_exports.string().nullable().default(null),\n target: turnRequestTargetSchema.default(LEGACY_TURN_REQUEST_TARGET),\n execution: resolvedThreadExecutionOptionsSchema\n });\n function parseStoredTurnRequestEventData(args) {\n return storedTurnRequestEventDataSchema.parse(args.data);\n }\n function toStoredThreadEventData(event) {\n const { scope: _scope, threadId: _threadId, type: _type, ...data } = event;\n return data;\n }\n function omitStoredScopeFields(data) {\n const { scope: _scope, turnId: _turnId, ...rest } = data;\n return rest;\n }\n function parseStoredThreadEvent(args) {\n const scopeResult = threadEventScopeSchema.safeParse(args.scope);\n if (!scopeResult.success) {\n throw new Error(\"Stored thread event is missing valid scope\");\n }\n const scope = scopeResult.data;\n const eventData = storedTurnRequestTypeSet.has(args.type) ? parseStoredTurnRequestEventData(args) : args.data;\n return threadEventSchema.parse({\n ...omitStoredScopeFields(eventData),\n ...args.providerThreadId != null ? { providerThreadId: args.providerThreadId } : {},\n scope,\n threadId: args.threadId,\n type: args.type\n });\n }\n function buildThreadEventRow(args) {\n const { event, ...row } = args;\n return {\n ...row,\n type: event.type,\n data: toStoredThreadEventData(event)\n };\n }\n function parseThreadEventRowInput(row) {\n return buildThreadEventRow({\n id: row.id,\n scope: row.scope,\n threadId: row.threadId,\n seq: row.seq,\n createdAt: row.createdAt,\n event: parseStoredThreadEvent({\n type: row.type,\n data: row.data,\n threadId: row.threadId,\n scope: row.scope\n })\n });\n }\n function parseThreadEventRow(value) {\n const row = threadEventRowInputSchema.parse(value);\n return parseThreadEventRowInput(row);\n }\n var threadEventRowSchema = threadEventRowInputSchema.transform(\n (row) => parseThreadEventRowInput(row)\n );\n\n // ../domain/src/claude-task-tools.ts\n var claudeTaskToolNameValues = [\n \"TaskCreate\",\n \"TaskGet\",\n \"TaskList\",\n \"TaskUpdate\"\n ];\n var claudeTaskToolNameSchema = external_exports.enum(claudeTaskToolNameValues);\n var claudeTaskStatusValues = [\n \"pending\",\n \"in_progress\",\n \"completed\"\n ];\n var claudeTaskStatusSchema = external_exports.enum(claudeTaskStatusValues);\n var claudeTaskUpdateStatusValues = [\n ...claudeTaskStatusValues,\n \"deleted\"\n ];\n var claudeTaskUpdateStatusSchema = external_exports.enum(\n claudeTaskUpdateStatusValues\n );\n var claudeTaskListStatusValues = [\n ...claudeTaskStatusValues,\n \"deleted\"\n ];\n var claudeTaskListStatusSchema = external_exports.enum(claudeTaskListStatusValues);\n var claudeTaskCreateArgsSchema = external_exports.object({\n activeForm: external_exports.string().optional(),\n subject: external_exports.string()\n }).passthrough();\n var claudeTaskGetArgsSchema = external_exports.object({\n taskId: external_exports.string()\n }).passthrough();\n var claudeTaskUpdateArgsSchema = external_exports.object({\n activeForm: external_exports.string().optional(),\n status: claudeTaskUpdateStatusSchema.optional(),\n subject: external_exports.string().optional(),\n taskId: external_exports.string()\n }).passthrough();\n var claudeTaskCreateOutputSchema = external_exports.object({\n task: external_exports.object({\n id: external_exports.string(),\n subject: external_exports.string()\n }).passthrough()\n }).passthrough();\n var claudeTaskGetOutputTaskSchema = external_exports.object({\n id: external_exports.string(),\n status: claudeTaskStatusSchema,\n subject: external_exports.string()\n }).passthrough();\n var claudeTaskGetOutputSchema = external_exports.object({\n task: claudeTaskGetOutputTaskSchema.nullable()\n }).passthrough();\n var claudeTaskUpdateOutputSchema = external_exports.object({\n success: external_exports.boolean(),\n taskId: external_exports.string()\n }).passthrough();\n var claudeTaskListItemSchema = external_exports.object({\n id: external_exports.string(),\n status: claudeTaskListStatusSchema,\n subject: external_exports.string()\n }).passthrough();\n var claudeTaskListOutputSchema = external_exports.object({\n tasks: external_exports.array(external_exports.unknown())\n }).passthrough();\n var claudeTaskToolOutputSchema = external_exports.union([\n claudeTaskCreateOutputSchema,\n claudeTaskGetOutputSchema,\n claudeTaskListOutputSchema,\n claudeTaskUpdateOutputSchema\n ]);\n\n // ../domain/src/active-thinking.ts\n var activeThinkingSchema = external_exports.object({\n id: external_exports.string(),\n text: external_exports.string(),\n startedAt: external_exports.number(),\n updatedAt: external_exports.number()\n });\n\n // ../domain/src/thread-timeline-pending-todos.ts\n var threadTimelinePendingTodoItemStatusSchema = external_exports.enum([\n \"pending\",\n \"in_progress\",\n \"completed\"\n ]);\n var threadTimelinePendingTodoItemSchema = external_exports.object({\n id: external_exports.string(),\n text: external_exports.string(),\n status: threadTimelinePendingTodoItemStatusSchema\n });\n var threadTimelinePendingTodosSchema = external_exports.object({\n sourceSeq: external_exports.number().int().nonnegative(),\n updatedAt: external_exports.number(),\n items: external_exports.array(threadTimelinePendingTodoItemSchema)\n });\n\n // ../domain/src/change-kinds.ts\n var REALTIME_ENTITIES = [\n \"thread\",\n \"project\",\n \"environment\",\n \"host\",\n \"system\",\n \"app\"\n ];\n var realtimeEntitySchema = external_exports.enum(REALTIME_ENTITIES);\n var THREAD_CHANGE_KINDS = [\n \"thread-created\",\n \"thread-deleted\",\n \"events-appended\",\n \"interactions-changed\",\n \"status-changed\",\n \"title-changed\",\n \"queue-changed\",\n \"archived-changed\",\n \"pin-state-changed\",\n \"parent-changed\",\n \"read-state-changed\",\n \"manager-assignment-changed\",\n \"order-changed\",\n \"terminals-changed\"\n ];\n var PROJECT_CHANGE_KINDS = [\n \"project-created\",\n \"project-updated\",\n \"project-deleted\",\n \"project-sources-changed\",\n \"threads-changed\",\n \"project-order-changed\",\n \"automations-changed\",\n \"nudges-changed\"\n ];\n var ENVIRONMENT_CHANGE_KINDS = [\n \"environment-created\",\n \"environment-deleted\",\n \"metadata-changed\",\n \"status-changed\",\n \"work-status-changed\",\n \"git-refs-changed\",\n \"thread-storage-changed\"\n ];\n var HOST_CHANGE_KINDS = [\n \"host-connected\",\n \"host-disconnected\"\n ];\n var SYSTEM_CHANGE_KINDS = [\"config-changed\", \"apps-changed\"];\n var APP_CHANGE_KINDS = [\"apps-changed\", \"content-changed\"];\n var threadChangeKindSchema = external_exports.enum(THREAD_CHANGE_KINDS);\n var projectChangeKindSchema = external_exports.enum(PROJECT_CHANGE_KINDS);\n var environmentChangeKindSchema = external_exports.enum(ENVIRONMENT_CHANGE_KINDS);\n var hostChangeKindSchema = external_exports.enum(HOST_CHANGE_KINDS);\n var systemChangeKindSchema = external_exports.enum(SYSTEM_CHANGE_KINDS);\n var appChangeKindSchema = external_exports.enum(APP_CHANGE_KINDS);\n var subscribeMessageSchema = external_exports.object({\n type: external_exports.literal(\"subscribe\"),\n entity: realtimeEntitySchema,\n id: external_exports.string().optional()\n });\n var unsubscribeMessageSchema = external_exports.object({\n type: external_exports.literal(\"unsubscribe\"),\n entity: realtimeEntitySchema,\n id: external_exports.string().optional()\n });\n var clientMessageSchema = external_exports.discriminatedUnion(\"type\", [\n subscribeMessageSchema,\n unsubscribeMessageSchema\n ]);\n var threadChangeMetadataSchema = external_exports.object({\n eventTypes: external_exports.array(threadEventTypeSchema).readonly().optional(),\n hasPendingInteraction: external_exports.boolean().optional(),\n projectId: external_exports.string().optional()\n }).strict();\n var threadChangedMessageSchema = external_exports.object({\n type: external_exports.literal(\"changed\"),\n entity: external_exports.literal(\"thread\"),\n id: external_exports.string().optional(),\n metadata: threadChangeMetadataSchema.optional(),\n changes: external_exports.array(threadChangeKindSchema).readonly()\n }).strict();\n var projectChangedMessageSchema = external_exports.object({\n type: external_exports.literal(\"changed\"),\n entity: external_exports.literal(\"project\"),\n id: external_exports.string().optional(),\n changes: external_exports.array(projectChangeKindSchema).readonly()\n }).strict();\n var environmentChangedMessageSchema = external_exports.object({\n type: external_exports.literal(\"changed\"),\n entity: external_exports.literal(\"environment\"),\n id: external_exports.string().optional(),\n changes: external_exports.array(environmentChangeKindSchema).readonly()\n }).strict();\n var hostChangedMessageSchema = external_exports.object({\n type: external_exports.literal(\"changed\"),\n entity: external_exports.literal(\"host\"),\n id: external_exports.string().optional(),\n changes: external_exports.array(hostChangeKindSchema).readonly()\n }).strict();\n var systemChangedMessageSchema = external_exports.object({\n type: external_exports.literal(\"changed\"),\n entity: external_exports.literal(\"system\"),\n changes: external_exports.array(systemChangeKindSchema).readonly()\n }).strict();\n var appChangedMessageSchema = external_exports.object({\n type: external_exports.literal(\"changed\"),\n entity: external_exports.literal(\"app\"),\n id: external_exports.string().optional(),\n changes: external_exports.array(appChangeKindSchema).readonly()\n }).strict();\n var changedMessageSchema = external_exports.discriminatedUnion(\"entity\", [\n threadChangedMessageSchema,\n projectChangedMessageSchema,\n environmentChangedMessageSchema,\n hostChangedMessageSchema,\n systemChangedMessageSchema,\n appChangedMessageSchema\n ]);\n function lenientKinds(kinds) {\n const known = new Set(kinds);\n return external_exports.array(external_exports.string()).transform(\n (values) => values.filter((value) => known.has(value))\n );\n }\n var knownThreadEventTypes = new Set(\n threadEventTypeValues\n );\n var threadChangeMetadataLenientSchema = external_exports.object({\n eventTypes: external_exports.array(external_exports.string()).transform(\n (values) => values.filter(\n (value) => knownThreadEventTypes.has(value)\n )\n ).optional(),\n hasPendingInteraction: external_exports.boolean().optional(),\n projectId: external_exports.string().optional()\n });\n var threadChangedMessageLenientSchema = external_exports.object({\n type: external_exports.literal(\"changed\"),\n entity: external_exports.literal(\"thread\"),\n id: external_exports.string().optional(),\n metadata: threadChangeMetadataLenientSchema.optional(),\n changes: lenientKinds(THREAD_CHANGE_KINDS)\n });\n var projectChangedMessageLenientSchema = external_exports.object({\n type: external_exports.literal(\"changed\"),\n entity: external_exports.literal(\"project\"),\n id: external_exports.string().optional(),\n changes: lenientKinds(PROJECT_CHANGE_KINDS)\n });\n var environmentChangedMessageLenientSchema = external_exports.object({\n type: external_exports.literal(\"changed\"),\n entity: external_exports.literal(\"environment\"),\n id: external_exports.string().optional(),\n changes: lenientKinds(ENVIRONMENT_CHANGE_KINDS)\n });\n var hostChangedMessageLenientSchema = external_exports.object({\n type: external_exports.literal(\"changed\"),\n entity: external_exports.literal(\"host\"),\n id: external_exports.string().optional(),\n changes: lenientKinds(HOST_CHANGE_KINDS)\n });\n var systemChangedMessageLenientSchema = external_exports.object({\n type: external_exports.literal(\"changed\"),\n entity: external_exports.literal(\"system\"),\n changes: lenientKinds(SYSTEM_CHANGE_KINDS)\n });\n var appChangedMessageLenientSchema = external_exports.object({\n type: external_exports.literal(\"changed\"),\n entity: external_exports.literal(\"app\"),\n id: external_exports.string().optional(),\n changes: lenientKinds(APP_CHANGE_KINDS)\n });\n var changedMessageLenientSchema = external_exports.discriminatedUnion(\"entity\", [\n threadChangedMessageLenientSchema,\n projectChangedMessageLenientSchema,\n environmentChangedMessageLenientSchema,\n hostChangedMessageLenientSchema,\n systemChangedMessageLenientSchema,\n appChangedMessageLenientSchema\n ]);\n\n // ../server-contract/src/errors.ts\n var domainErrorCodeSchema = external_exports.enum([\n \"invalid_request\",\n \"invalid_manifest\",\n \"awaiting_user_interaction\",\n \"thread_not_found\",\n \"project_not_found\",\n \"thread_archived\",\n \"inactive_session\",\n \"provider_unavailable\",\n \"provider_timeout\",\n \"provider_rpc_error\",\n \"unsupported_operation\",\n \"no_active_turn\",\n \"internal_error\",\n \"environment_not_ready\",\n \"thread_not_writable\",\n \"thread_environment_unavailable\",\n \"host_unavailable\",\n \"project_unavailable\",\n \"parent_thread_invalid\"\n ]);\n var apiErrorSchema = external_exports.object({\n code: external_exports.string().min(1),\n message: external_exports.string(),\n details: external_exports.unknown().optional(),\n retryable: external_exports.boolean().optional()\n });\n var environmentNotReadyErrorDetailsSchema = external_exports.object({\n environmentStatus: environmentStatusSchema,\n hasPath: external_exports.boolean(),\n cleanupRequestedAt: external_exports.number().int().nonnegative().nullable()\n });\n var threadNotWritableReasonSchema = external_exports.enum([\n \"archived\",\n \"stopping\",\n \"deleted\",\n \"not_started\",\n \"not_active\",\n \"errored\",\n \"already_active\",\n \"still_starting\"\n ]);\n var threadNotWritableErrorDetailsSchema = external_exports.object({\n reason: threadNotWritableReasonSchema,\n archivedAt: external_exports.number().int().nonnegative().nullable(),\n stopRequestedAt: external_exports.number().int().nonnegative().nullable(),\n threadStatus: threadStatusSchema\n });\n var threadEnvironmentUnavailableReasonSchema = external_exports.enum([\n \"never_attached\",\n \"destroyed\",\n \"destroying\",\n \"provisioning\",\n \"errored\"\n ]);\n var threadEnvironmentUnavailableErrorDetailsSchema = external_exports.object({\n reason: threadEnvironmentUnavailableReasonSchema,\n environmentStatus: environmentStatusSchema.nullable()\n });\n var hostUnavailableReasonSchema = external_exports.enum([\n \"suspended\",\n \"disconnected\",\n \"destroyed\"\n ]);\n var hostUnavailableErrorDetailsSchema = external_exports.object({\n reason: hostUnavailableReasonSchema,\n hostStatus: hostStatusSchema.nullable(),\n suspendedAt: external_exports.number().int().nonnegative().nullable(),\n destroyedAt: external_exports.number().int().nonnegative().nullable()\n });\n var projectUnavailableReasonSchema = external_exports.enum([\n \"deleted\",\n \"pending_deletion\"\n ]);\n var projectUnavailableErrorDetailsSchema = external_exports.object({\n reason: projectUnavailableReasonSchema,\n deletedAt: external_exports.number().int().nonnegative().nullable()\n });\n var parentThreadInvalidReasonSchema = external_exports.enum([\n \"not_found\",\n \"archived\",\n \"deleted\",\n \"wrong_project\",\n \"not_a_manager\"\n ]);\n var parentThreadInvalidSubjectSchema = external_exports.enum([\"parent\", \"sender\"]);\n var parentThreadInvalidErrorDetailsSchema = external_exports.object({\n reason: parentThreadInvalidReasonSchema,\n subject: parentThreadInvalidSubjectSchema\n });\n var environmentNotReadyApiErrorSchema = apiErrorSchema.extend({\n code: external_exports.literal(\"environment_not_ready\"),\n details: environmentNotReadyErrorDetailsSchema\n });\n var threadNotWritableApiErrorSchema = apiErrorSchema.extend({\n code: external_exports.literal(\"thread_not_writable\"),\n details: threadNotWritableErrorDetailsSchema\n });\n var threadEnvironmentUnavailableApiErrorSchema = apiErrorSchema.extend({\n code: external_exports.literal(\"thread_environment_unavailable\"),\n details: threadEnvironmentUnavailableErrorDetailsSchema\n });\n var hostUnavailableApiErrorSchema = apiErrorSchema.extend({\n code: external_exports.literal(\"host_unavailable\"),\n details: hostUnavailableErrorDetailsSchema\n });\n var projectUnavailableApiErrorSchema = apiErrorSchema.extend({\n code: external_exports.literal(\"project_unavailable\"),\n details: projectUnavailableErrorDetailsSchema\n });\n var parentThreadInvalidApiErrorSchema = apiErrorSchema.extend({\n code: external_exports.literal(\"parent_thread_invalid\"),\n details: parentThreadInvalidErrorDetailsSchema\n });\n var lifecycleApiErrorSchema = external_exports.discriminatedUnion(\"code\", [\n environmentNotReadyApiErrorSchema,\n threadNotWritableApiErrorSchema,\n threadEnvironmentUnavailableApiErrorSchema,\n hostUnavailableApiErrorSchema,\n projectUnavailableApiErrorSchema,\n parentThreadInvalidApiErrorSchema\n ]);\n\n // ../server-contract/src/thread-timeline.ts\n var timelineRowStatusValues = [\n \"pending\",\n \"completed\",\n \"error\",\n \"interrupted\"\n ];\n var timelineRowStatusSchema = external_exports.enum(timelineRowStatusValues);\n var timelineApprovalStatusValues = [\n \"waiting_for_approval\",\n \"denied\"\n ];\n var timelineApprovalStatusSchema = external_exports.enum(timelineApprovalStatusValues).nullable();\n var timelineActivityIntentSchema = external_exports.discriminatedUnion(\"type\", [\n external_exports.object({\n type: external_exports.literal(\"read\"),\n command: external_exports.string(),\n name: external_exports.string(),\n path: external_exports.string().nullable()\n }),\n external_exports.object({\n type: external_exports.literal(\"list_files\"),\n command: external_exports.string(),\n path: external_exports.string().nullable()\n }),\n external_exports.object({\n type: external_exports.literal(\"search\"),\n command: external_exports.string(),\n query: external_exports.string().nullable(),\n path: external_exports.string().nullable()\n }),\n external_exports.object({\n type: external_exports.literal(\"unknown\"),\n command: external_exports.string()\n })\n ]);\n var timelineRowBaseSchema = external_exports.object({\n id: external_exports.string(),\n threadId: external_exports.string(),\n turnId: external_exports.string().nullable(),\n sourceSeqStart: external_exports.number().int(),\n sourceSeqEnd: external_exports.number().int(),\n startedAt: external_exports.number(),\n createdAt: external_exports.number()\n });\n var timelineConversationAttachmentsSchema = external_exports.object({\n webImages: external_exports.number().int().nonnegative(),\n localImages: external_exports.number().int().nonnegative(),\n localFiles: external_exports.number().int().nonnegative(),\n imageUrls: external_exports.array(external_exports.string()),\n localImagePaths: external_exports.array(external_exports.string()),\n localFilePaths: external_exports.array(external_exports.string())\n });\n var timelineConversationTurnRequestKindValues = [\n \"message\",\n \"steer\"\n ];\n var timelineConversationTurnRequestStatusValues = [\n \"pending\",\n \"accepted\"\n ];\n var timelineConversationTurnRequestSchema = external_exports.object({\n kind: external_exports.enum(timelineConversationTurnRequestKindValues),\n status: external_exports.enum(timelineConversationTurnRequestStatusValues)\n });\n var timelineConversationRowBaseSchema = timelineRowBaseSchema.extend({\n kind: external_exports.literal(\"conversation\"),\n text: external_exports.string(),\n attachments: timelineConversationAttachmentsSchema.nullable()\n });\n var timelineUserConversationRowSchema = timelineConversationRowBaseSchema.extend({\n role: external_exports.literal(\"user\"),\n initiator: threadTurnInitiatorSchema,\n senderThreadId: external_exports.string().nullable(),\n turnRequest: timelineConversationTurnRequestSchema\n });\n var timelineAssistantConversationRowSchema = timelineConversationRowBaseSchema.extend({\n role: external_exports.literal(\"assistant\"),\n turnRequest: external_exports.null()\n });\n var timelineConversationRowSchema = external_exports.discriminatedUnion(\"role\", [\n timelineUserConversationRowSchema,\n timelineAssistantConversationRowSchema\n ]);\n var timelineSystemOperationKindValues = [\n \"generic\",\n \"compaction\",\n \"manager-assignment\",\n \"thread-provisioning\",\n \"thread-interrupted\",\n \"provider-unhandled\",\n \"warning\",\n \"deprecation\"\n ];\n var timelineSystemOperationKindSchema = external_exports.enum(\n timelineSystemOperationKindValues\n );\n var timelineGenericSystemOperationKindSchema = external_exports.enum([\n \"generic\",\n \"compaction\",\n \"thread-provisioning\",\n \"thread-interrupted\",\n \"provider-unhandled\",\n \"warning\",\n \"deprecation\"\n ]);\n var timelineManagerAssignmentActionValues = [\n \"assign\",\n \"release\",\n \"transfer\"\n ];\n var timelineManagerAssignmentActionSchema = external_exports.enum(\n timelineManagerAssignmentActionValues\n );\n var timelineManagerAssignmentSchema = external_exports.object({\n action: timelineManagerAssignmentActionSchema,\n previousManagerThreadId: external_exports.string().nullable(),\n previousManagerThreadTitle: external_exports.string().nullable(),\n nextManagerThreadId: external_exports.string().nullable(),\n nextManagerThreadTitle: external_exports.string().nullable()\n });\n var timelineSystemRowBaseSchema = timelineRowBaseSchema.extend({\n kind: external_exports.literal(\"system\"),\n title: external_exports.string(),\n detail: external_exports.string().nullable(),\n status: timelineRowStatusSchema.nullable()\n });\n var timelineNonOperationSystemRowSchema = timelineSystemRowBaseSchema.extend({\n systemKind: external_exports.enum([\"debug\", \"error\", \"reconnect\"])\n });\n var timelineGenericOperationSystemRowSchema = timelineSystemRowBaseSchema.extend({\n systemKind: external_exports.literal(\"operation\"),\n operationKind: timelineGenericSystemOperationKindSchema,\n completedAt: external_exports.number().nullable()\n });\n var timelineManagerAssignmentSystemRowSchema = timelineSystemRowBaseSchema.extend({\n systemKind: external_exports.literal(\"operation\"),\n operationKind: external_exports.literal(\"manager-assignment\"),\n status: timelineRowStatusSchema,\n managerAssignment: timelineManagerAssignmentSchema,\n completedAt: external_exports.number().nullable()\n });\n var timelineOperationSystemRowSchema = external_exports.discriminatedUnion(\n \"operationKind\",\n [\n timelineGenericOperationSystemRowSchema,\n timelineManagerAssignmentSystemRowSchema\n ]\n );\n var timelineSystemRowSchema = external_exports.union([\n timelineNonOperationSystemRowSchema,\n timelineOperationSystemRowSchema\n ]);\n var timelineDiffStatsSchema = external_exports.object({\n added: external_exports.number().int().nonnegative(),\n removed: external_exports.number().int().nonnegative()\n });\n var timelineFileChangeSchema = external_exports.object({\n path: external_exports.string(),\n kind: external_exports.string().nullable(),\n movePath: external_exports.string().nullable(),\n diff: external_exports.string().nullable(),\n diffStats: timelineDiffStatsSchema\n });\n var timelineWorkRowBaseSchema = timelineRowBaseSchema.extend({\n kind: external_exports.literal(\"work\"),\n status: timelineRowStatusSchema\n });\n var timelineCommandWorkRowSchema = timelineWorkRowBaseSchema.extend({\n workKind: external_exports.literal(\"command\"),\n callId: external_exports.string(),\n command: external_exports.string(),\n cwd: external_exports.string().nullable(),\n source: external_exports.string().nullable(),\n output: external_exports.string(),\n exitCode: external_exports.number().nullable(),\n completedAt: external_exports.number().nullable(),\n approvalStatus: timelineApprovalStatusSchema,\n activityIntents: external_exports.array(timelineActivityIntentSchema)\n });\n var timelineToolWorkRowSchema = timelineWorkRowBaseSchema.extend({\n workKind: external_exports.literal(\"tool\"),\n callId: external_exports.string(),\n toolName: external_exports.string(),\n toolArgs: external_exports.record(external_exports.string(), jsonValueSchema).nullable(),\n output: external_exports.string(),\n completedAt: external_exports.number().nullable(),\n approvalStatus: timelineApprovalStatusSchema,\n activityIntents: external_exports.array(timelineActivityIntentSchema)\n });\n var timelineFileChangeWorkRowSchema = timelineWorkRowBaseSchema.extend(\n {\n workKind: external_exports.literal(\"file-change\"),\n callId: external_exports.string(),\n change: timelineFileChangeSchema,\n stdout: external_exports.string().nullable(),\n stderr: external_exports.string().nullable(),\n approvalStatus: timelineApprovalStatusSchema\n }\n );\n var timelineWebSearchWorkRowSchema = timelineWorkRowBaseSchema.extend({\n workKind: external_exports.literal(\"web-search\"),\n callId: external_exports.string(),\n queries: external_exports.array(external_exports.string()),\n completedAt: external_exports.number().nullable()\n });\n var timelineWebFetchWorkRowSchema = timelineWorkRowBaseSchema.extend({\n workKind: external_exports.literal(\"web-fetch\"),\n callId: external_exports.string(),\n url: external_exports.string(),\n prompt: external_exports.string().nullable(),\n pattern: external_exports.string().nullable(),\n completedAt: external_exports.number().nullable()\n });\n var timelineImageViewWorkRowSchema = timelineWorkRowBaseSchema.extend({\n workKind: external_exports.literal(\"image-view\"),\n callId: external_exports.string(),\n path: external_exports.string(),\n completedAt: external_exports.number().nullable()\n });\n var timelineFileEditApprovalLifecycleValues = [\n \"waiting\",\n \"denied\"\n ];\n var timelinePermissionGrantApprovalLifecycleValues = [\n \"pending\",\n \"resolving\",\n \"granted\",\n \"denied\",\n \"interrupted\",\n \"expired\"\n ];\n var timelineQuestionLifecycleValues = [\n \"pending\",\n \"resolving\",\n \"answered\",\n \"interrupted\",\n \"expired\"\n ];\n var timelinePermissionGrantApprovalGrantScopeValues = [\n \"turn\",\n \"session\"\n ];\n var timelinePermissionGrantApprovalGrantScopeSchema = external_exports.enum(\n timelinePermissionGrantApprovalGrantScopeValues\n );\n var timelineApprovalTargetSchema = external_exports.object({\n itemId: external_exports.string(),\n toolName: external_exports.string().nullable()\n });\n var timelineApprovalWorkRowBaseSchema = timelineWorkRowBaseSchema.extend({\n workKind: external_exports.literal(\"approval\"),\n interactionId: external_exports.string(),\n target: timelineApprovalTargetSchema\n });\n var timelineFileEditApprovalWorkRowSchema = timelineApprovalWorkRowBaseSchema.extend({\n approvalKind: external_exports.literal(\"file-edit\"),\n lifecycle: external_exports.enum(timelineFileEditApprovalLifecycleValues)\n });\n var timelinePermissionGrantApprovalWorkRowSchema = timelineApprovalWorkRowBaseSchema.extend({\n approvalKind: external_exports.literal(\"permission-grant\"),\n lifecycle: external_exports.enum(timelinePermissionGrantApprovalLifecycleValues),\n grantScope: timelinePermissionGrantApprovalGrantScopeSchema.nullable(),\n statusReason: external_exports.string().nullable()\n });\n var timelineApprovalWorkRowSchema = external_exports.discriminatedUnion(\n \"approvalKind\",\n [\n timelineFileEditApprovalWorkRowSchema,\n timelinePermissionGrantApprovalWorkRowSchema\n ]\n );\n var timelineQuestionWorkRowSchema = timelineWorkRowBaseSchema.extend({\n workKind: external_exports.literal(\"question\"),\n interactionId: external_exports.string(),\n lifecycle: external_exports.enum(timelineQuestionLifecycleValues),\n questions: external_exports.array(pendingInteractionUserQuestionQuestionSchema),\n answers: external_exports.record(external_exports.string(), pendingInteractionUserAnswerSchema).nullable(),\n statusReason: external_exports.string().nullable()\n });\n var timelineDelegationWorkRowSchema = timelineWorkRowBaseSchema.extend({\n workKind: external_exports.literal(\"delegation\"),\n callId: external_exports.string(),\n toolName: external_exports.string(),\n subagentType: external_exports.string().nullable(),\n description: external_exports.string().nullable(),\n output: external_exports.string(),\n completedAt: external_exports.number().nullable(),\n childRows: external_exports.array(external_exports.lazy(() => timelineRowSchema))\n });\n var timelineWorkflowWorkRowSchema = timelineWorkRowBaseSchema.extend({\n workKind: external_exports.literal(\"workflow\"),\n itemId: external_exports.string(),\n workflowName: external_exports.string().nullable(),\n description: external_exports.string(),\n taskStatus: backgroundTaskStatusSchema,\n workflow: workflowProgressSnapshotSchema.nullable(),\n usage: backgroundTaskUsageSchema.nullable(),\n summary: external_exports.string().nullable(),\n error: external_exports.string().nullable(),\n completedAt: external_exports.number().nullable()\n });\n var timelineWorkRowSchema = external_exports.union([\n timelineCommandWorkRowSchema,\n timelineToolWorkRowSchema,\n timelineFileChangeWorkRowSchema,\n timelineWebSearchWorkRowSchema,\n timelineWebFetchWorkRowSchema,\n timelineImageViewWorkRowSchema,\n timelineApprovalWorkRowSchema,\n timelineQuestionWorkRowSchema,\n timelineDelegationWorkRowSchema,\n timelineWorkflowWorkRowSchema\n ]);\n var timelineTurnRowSchema = external_exports.lazy(\n () => timelineRowBaseSchema.extend({\n kind: external_exports.literal(\"turn\"),\n turnId: external_exports.string().min(1),\n status: timelineRowStatusSchema,\n summaryCount: external_exports.number().int().nonnegative(),\n completedAt: external_exports.number().nullable(),\n children: external_exports.array(timelineRowSchema).nullable()\n })\n );\n var timelineRowSchema = external_exports.lazy(\n () => external_exports.union([\n timelineConversationRowSchema,\n timelineWorkRowSchema,\n timelineSystemRowSchema,\n timelineTurnRowSchema\n ])\n );\n\n // ../host-daemon-contract/src/local-state.ts\n var nonEmptyTrimmedStringSchema = external_exports.string().trim().min(1);\n var hostAuthStateSchema = external_exports.object({\n hostId: external_exports.string().min(1),\n hostKey: nonEmptyTrimmedStringSchema,\n hostType: hostTypeSchema,\n // Legacy auth files included serverUrl. Accept it so old files keep\n // loading, but strip it from the parsed auth state.\n serverUrl: external_exports.unknown().optional()\n }).strict().transform(({ hostId, hostKey, hostType }) => ({\n hostId,\n hostKey,\n hostType\n }));\n\n // ../../node_modules/.pnpm/hono@4.11.9/node_modules/hono/dist/utils/cookie.js\n var _serialize = (name, value, opt = {}) => {\n let cookie = `${name}=${value}`;\n if (name.startsWith(\"__Secure-\") && !opt.secure) {\n throw new Error(\"__Secure- Cookie must have Secure attributes\");\n }\n if (name.startsWith(\"__Host-\")) {\n if (!opt.secure) {\n throw new Error(\"__Host- Cookie must have Secure attributes\");\n }\n if (opt.path !== \"/\") {\n throw new Error('__Host- Cookie must have Path attributes with \"/\"');\n }\n if (opt.domain) {\n throw new Error(\"__Host- Cookie must not have Domain attributes\");\n }\n }\n if (opt && typeof opt.maxAge === \"number\" && opt.maxAge >= 0) {\n if (opt.maxAge > 3456e4) {\n throw new Error(\n \"Cookies Max-Age SHOULD NOT be greater than 400 days (34560000 seconds) in duration.\"\n );\n }\n cookie += `; Max-Age=${opt.maxAge | 0}`;\n }\n if (opt.domain && opt.prefix !== \"host\") {\n cookie += `; Domain=${opt.domain}`;\n }\n if (opt.path) {\n cookie += `; Path=${opt.path}`;\n }\n if (opt.expires) {\n if (opt.expires.getTime() - Date.now() > 3456e7) {\n throw new Error(\n \"Cookies Expires SHOULD NOT be greater than 400 days (34560000 seconds) in the future.\"\n );\n }\n cookie += `; Expires=${opt.expires.toUTCString()}`;\n }\n if (opt.httpOnly) {\n cookie += \"; HttpOnly\";\n }\n if (opt.secure) {\n cookie += \"; Secure\";\n }\n if (opt.sameSite) {\n cookie += `; SameSite=${opt.sameSite.charAt(0).toUpperCase() + opt.sameSite.slice(1)}`;\n }\n if (opt.priority) {\n cookie += `; Priority=${opt.priority.charAt(0).toUpperCase() + opt.priority.slice(1)}`;\n }\n if (opt.partitioned) {\n if (!opt.secure) {\n throw new Error(\"Partitioned Cookie must have Secure attributes\");\n }\n cookie += \"; Partitioned\";\n }\n return cookie;\n };\n var serialize = (name, value, opt) => {\n value = encodeURIComponent(value);\n return _serialize(name, value, opt);\n };\n\n // ../../node_modules/.pnpm/hono@4.11.9/node_modules/hono/dist/client/utils.js\n var mergePath = (base, path) => {\n base = base.replace(/\\/+$/, \"\");\n base = base + \"/\";\n path = path.replace(/^\\/+/, \"\");\n return base + path;\n };\n var replaceUrlParam = (urlString, params) => {\n for (const [k, v] of Object.entries(params)) {\n const reg = new RegExp(\"/:\" + k + \"(?:{[^/]+})?\\\\??\");\n urlString = urlString.replace(reg, v ? `/${v}` : \"\");\n }\n return urlString;\n };\n var buildSearchParams = (query) => {\n const searchParams = new URLSearchParams();\n for (const [k, v] of Object.entries(query)) {\n if (v === void 0) {\n continue;\n }\n if (Array.isArray(v)) {\n for (const v2 of v) {\n searchParams.append(k, v2);\n }\n } else {\n searchParams.set(k, v);\n }\n }\n return searchParams;\n };\n var replaceUrlProtocol = (urlString, protocol) => {\n switch (protocol) {\n case \"ws\":\n return urlString.replace(/^http/, \"ws\");\n case \"http\":\n return urlString.replace(/^ws/, \"http\");\n }\n };\n var removeIndexString = (urlString) => {\n if (/^https?:\\/\\/[^\\/]+?\\/index(?=\\?|$)/.test(urlString)) {\n return urlString.replace(/\\/index(?=\\?|$)/, \"/\");\n }\n return urlString.replace(/\\/index(?=\\?|$)/, \"\");\n };\n function isObject2(item) {\n return typeof item === \"object\" && item !== null && !Array.isArray(item);\n }\n function deepMerge(target, source) {\n if (!isObject2(target) && !isObject2(source)) {\n return source;\n }\n const merged = { ...target };\n for (const key in source) {\n const value = source[key];\n if (isObject2(merged[key]) && isObject2(value)) {\n merged[key] = deepMerge(merged[key], value);\n } else {\n merged[key] = value;\n }\n }\n return merged;\n }\n\n // ../../node_modules/.pnpm/hono@4.11.9/node_modules/hono/dist/client/client.js\n var createProxy = (callback, path) => {\n const proxy = new Proxy(() => {\n }, {\n get(_obj, key) {\n if (typeof key !== \"string\" || key === \"then\") {\n return void 0;\n }\n return createProxy(callback, [...path, key]);\n },\n apply(_1, _2, args) {\n return callback({\n path,\n args\n });\n }\n });\n return proxy;\n };\n var ClientRequestImpl = class {\n url;\n method;\n buildSearchParams;\n queryParams = void 0;\n pathParams = {};\n rBody;\n cType = void 0;\n constructor(url2, method, options) {\n this.url = url2;\n this.method = method;\n this.buildSearchParams = options.buildSearchParams;\n }\n fetch = async (args, opt) => {\n if (args) {\n if (args.query) {\n this.queryParams = this.buildSearchParams(args.query);\n }\n if (args.form) {\n const form = new FormData();\n for (const [k, v] of Object.entries(args.form)) {\n if (Array.isArray(v)) {\n for (const v2 of v) {\n form.append(k, v2);\n }\n } else {\n form.append(k, v);\n }\n }\n this.rBody = form;\n }\n if (args.json) {\n this.rBody = JSON.stringify(args.json);\n this.cType = \"application/json\";\n }\n if (args.param) {\n this.pathParams = args.param;\n }\n }\n let methodUpperCase = this.method.toUpperCase();\n const headerValues = {\n ...args?.header,\n ...typeof opt?.headers === \"function\" ? await opt.headers() : opt?.headers\n };\n if (args?.cookie) {\n const cookies = [];\n for (const [key, value] of Object.entries(args.cookie)) {\n cookies.push(serialize(key, value, { path: \"/\" }));\n }\n headerValues[\"Cookie\"] = cookies.join(\",\");\n }\n if (this.cType) {\n headerValues[\"Content-Type\"] = this.cType;\n }\n const headers = new Headers(headerValues ?? void 0);\n let url2 = this.url;\n url2 = removeIndexString(url2);\n url2 = replaceUrlParam(url2, this.pathParams);\n if (this.queryParams) {\n url2 = url2 + \"?\" + this.queryParams.toString();\n }\n methodUpperCase = this.method.toUpperCase();\n const setBody = !(methodUpperCase === \"GET\" || methodUpperCase === \"HEAD\");\n return (opt?.fetch || fetch)(url2, {\n body: setBody ? this.rBody : void 0,\n method: methodUpperCase,\n headers,\n ...opt?.init\n });\n };\n };\n var hc = (baseUrl, options) => createProxy(function proxyCallback(opts) {\n const buildSearchParamsOption = options?.buildSearchParams ?? buildSearchParams;\n const parts = [...opts.path];\n const lastParts = parts.slice(-3).reverse();\n if (lastParts[0] === \"toString\") {\n if (lastParts[1] === \"name\") {\n return lastParts[2] || \"\";\n }\n return proxyCallback.toString();\n }\n if (lastParts[0] === \"valueOf\") {\n if (lastParts[1] === \"name\") {\n return lastParts[2] || \"\";\n }\n return proxyCallback;\n }\n let method = \"\";\n if (/^\\$/.test(lastParts[0])) {\n const last = parts.pop();\n if (last) {\n method = last.replace(/^\\$/, \"\");\n }\n }\n const path = parts.join(\"/\");\n const url2 = mergePath(baseUrl, path);\n if (method === \"url\") {\n let result = url2;\n if (opts.args[0]) {\n if (opts.args[0].param) {\n result = replaceUrlParam(url2, opts.args[0].param);\n }\n if (opts.args[0].query) {\n result = result + \"?\" + buildSearchParamsOption(opts.args[0].query).toString();\n }\n }\n result = removeIndexString(result);\n return new URL(result);\n }\n if (method === \"ws\") {\n const webSocketUrl = replaceUrlProtocol(\n opts.args[0] && opts.args[0].param ? replaceUrlParam(url2, opts.args[0].param) : url2,\n \"ws\"\n );\n const targetUrl = new URL(webSocketUrl);\n const queryParams = opts.args[0]?.query;\n if (queryParams) {\n Object.entries(queryParams).forEach(([key, value]) => {\n if (Array.isArray(value)) {\n value.forEach((item) => targetUrl.searchParams.append(key, item));\n } else {\n targetUrl.searchParams.set(key, value);\n }\n });\n }\n const establishWebSocket = (...args) => {\n if (options?.webSocket !== void 0 && typeof options.webSocket === \"function\") {\n return options.webSocket(...args);\n }\n return new WebSocket(...args);\n };\n return establishWebSocket(targetUrl.toString());\n }\n const req = new ClientRequestImpl(url2, method, {\n buildSearchParams: buildSearchParamsOption\n });\n if (method) {\n options ??= {};\n const args = deepMerge(options, { ...opts.args[1] });\n return req.fetch(opts.args[0], args);\n }\n return req;\n }, []);\n\n // ../host-daemon-contract/src/local.ts\n var workspaceOpenTargetIdValues = [\n \"default-app\",\n \"vscode\",\n \"cursor\",\n \"sublime-text\",\n \"zed\",\n \"windsurf\",\n \"antigravity\",\n \"finder\",\n \"terminal\",\n \"iterm2\",\n \"ghostty\",\n \"xcode\"\n ];\n var workspaceOpenTargetIdSchema = external_exports.enum(workspaceOpenTargetIdValues);\n var workspaceOpenTargetCapabilitiesSchema = external_exports.object({\n openDirectory: external_exports.boolean(),\n openFile: external_exports.boolean(),\n openFileAtLine: external_exports.boolean()\n });\n var workspaceOpenTargetSchema = external_exports.object({\n id: workspaceOpenTargetIdSchema,\n label: external_exports.string().min(1),\n capabilities: workspaceOpenTargetCapabilitiesSchema\n });\n var workspaceOpenTargetsResponseSchema = external_exports.object({\n targets: external_exports.array(workspaceOpenTargetSchema)\n });\n var openTargetPathSchema = external_exports.string().min(1);\n var openTargetLineNumberSchema = external_exports.number().int().positive().nullable();\n var openInTargetRequestSchema = external_exports.object({\n lineNumber: openTargetLineNumberSchema,\n path: openTargetPathSchema,\n targetId: workspaceOpenTargetIdSchema\n });\n var pickFolderResponseSchema = external_exports.object({\n path: external_exports.string().nullable()\n });\n var PATHS_EXIST_MAX_PATHS = 200;\n var pathsExistRequestSchema = external_exports.object({\n paths: external_exports.array(external_exports.string().min(1)).min(1).max(PATHS_EXIST_MAX_PATHS).transform((paths) => Array.from(new Set(paths)))\n });\n var pathsExistResponseSchema = external_exports.object({\n existence: external_exports.record(external_exports.string(), external_exports.boolean())\n });\n var hostPlatformSchema = external_exports.enum([\"darwin\", \"linux\", \"wsl\", \"unknown\"]);\n var statusResponseSchema = external_exports.object({\n hostId: external_exports.string().min(1),\n connected: external_exports.boolean(),\n // Informational local-daemon protocol marker. Dev restart tooling uses it\n // to detect stale host-daemons; product UI must not gate behavior on it.\n protocolVersion: external_exports.number().int().positive(),\n serverUrl: external_exports.string(),\n supportsNativeFolderPicker: external_exports.boolean(),\n platform: hostPlatformSchema\n });\n var healthResponseSchema = external_exports.string().min(1);\n var providerCliKeyValues = [\"codex\", \"claudeCode\"];\n var providerCliKeySchema = external_exports.enum(providerCliKeyValues);\n var providerCliInstallOutputStreamValues = [\n \"stdout\",\n \"stderr\"\n ];\n var providerCliInstallOutputStreamSchema = external_exports.enum(\n providerCliInstallOutputStreamValues\n );\n var providerCliInstallSourceValues = [\n \"notInstalled\",\n \"npmGlobal\",\n \"external\"\n ];\n var providerCliInstallSourceSchema = external_exports.enum(\n providerCliInstallSourceValues\n );\n var providerCliInstallActionKindValues = [\n \"install\",\n \"update\"\n ];\n var providerCliInstallActionKindSchema = external_exports.enum(\n providerCliInstallActionKindValues\n );\n var providerCliInstallCommandKindValues = [\"exec\", \"shell\"];\n var providerCliInstallCommandKindSchema = external_exports.enum(\n providerCliInstallCommandKindValues\n );\n var providerCliInstallActionSchema = external_exports.object({\n kind: providerCliInstallActionKindSchema,\n label: external_exports.enum([\"Install\", \"Update\"]),\n commandKind: providerCliInstallCommandKindSchema,\n command: external_exports.string().min(1)\n });\n var providerCliStatusSchema = external_exports.object({\n displayName: external_exports.string().min(1),\n executableName: external_exports.string().min(1),\n executablePath: external_exports.string().min(1).nullable(),\n installed: external_exports.boolean(),\n installSource: providerCliInstallSourceSchema,\n currentVersion: external_exports.string().min(1).nullable(),\n latestVersion: external_exports.string().min(1).nullable(),\n npmPackageName: external_exports.string().min(1),\n npmGlobalPackageVersion: external_exports.string().min(1).nullable(),\n installAction: providerCliInstallActionSchema.nullable(),\n needsUpdate: external_exports.boolean()\n });\n var providerCliStatusResponseSchema = external_exports.object({\n codex: providerCliStatusSchema,\n claudeCode: providerCliStatusSchema\n });\n var providerCliInstallRequestSchema = external_exports.object({\n provider: providerCliKeySchema,\n actionKind: providerCliInstallActionKindSchema\n });\n var providerCliInstallStartedEventSchema = external_exports.object({\n type: external_exports.literal(\"started\"),\n provider: providerCliKeySchema,\n command: external_exports.string().min(1)\n });\n var providerCliInstallOutputEventSchema = external_exports.object({\n type: external_exports.literal(\"output\"),\n provider: providerCliKeySchema,\n stream: providerCliInstallOutputStreamSchema,\n text: external_exports.string()\n });\n var providerCliInstallCompletedEventSchema = external_exports.object({\n type: external_exports.literal(\"completed\"),\n provider: providerCliKeySchema,\n exitCode: external_exports.number().int().nullable(),\n signal: external_exports.string().min(1).nullable(),\n success: external_exports.boolean()\n });\n var providerCliInstallErrorEventSchema = external_exports.object({\n type: external_exports.literal(\"error\"),\n provider: providerCliKeySchema,\n message: external_exports.string().min(1)\n });\n var providerCliInstallEventSchema = external_exports.discriminatedUnion(\"type\", [\n providerCliInstallStartedEventSchema,\n providerCliInstallOutputEventSchema,\n providerCliInstallCompletedEventSchema,\n providerCliInstallErrorEventSchema\n ]);\n\n // ../agent-runtime/src/shared/json-rpc-envelope.ts\n var recordSchema = external_exports.record(external_exports.string(), external_exports.unknown());\n var jsonRpcEnvelopeSchema = external_exports.object({\n jsonrpc: external_exports.literal(\"2.0\"),\n method: external_exports.string(),\n params: recordSchema.optional()\n }).passthrough();\n var sdkMessageEnvelopeSchema = external_exports.object({\n jsonrpc: external_exports.literal(\"2.0\"),\n method: external_exports.literal(\"sdk/message\"),\n params: external_exports.object({\n message: external_exports.unknown(),\n threadId: external_exports.string().optional(),\n parent_tool_use_id: external_exports.string().optional()\n }).passthrough()\n }).passthrough();\n var threadIdentityEnvelopeSchema = external_exports.object({\n jsonrpc: external_exports.literal(\"2.0\"),\n method: external_exports.literal(\"thread/identity\"),\n params: external_exports.object({\n threadId: external_exports.string().optional(),\n providerThreadId: external_exports.string().optional()\n }).passthrough()\n }).passthrough();\n var threadContextWindowUsageEnvelopeSchema = external_exports.object({\n jsonrpc: external_exports.literal(\"2.0\"),\n method: external_exports.literal(\"thread/contextWindowUsage/updated\"),\n params: external_exports.object({\n threadId: external_exports.string().optional(),\n contextWindowUsage: external_exports.object({\n usedTokens: external_exports.number().nullable(),\n modelContextWindow: external_exports.number().nullable(),\n estimated: external_exports.boolean()\n })\n }).passthrough()\n }).passthrough();\n var errorEnvelopeSchema = external_exports.object({\n jsonrpc: external_exports.literal(\"2.0\"),\n method: external_exports.literal(\"error\"),\n params: external_exports.object({\n message: external_exports.string().optional()\n }).passthrough().optional()\n }).passthrough();\n\n // ../replay-capture/src/schema.ts\n var REPLAY_CAPTURE_SCHEMA_VERSION = 3;\n var REPLAY_CAPTURE_ID_PATTERN = /^cap_[0-9a-z]+_[0-9a-z]{8}$/u;\n var replayCaptureKindSchema = external_exports.enum([\"thread-start\", \"turn-start\"]);\n var replayCaptureSourceSchema = external_exports.enum([\n \"live-dev-capture\",\n \"corpus-fixture\"\n ]);\n var gitSnapshotSchema = external_exports.object({\n headSha: external_exports.string().nullable(),\n isClean: external_exports.boolean(),\n statusLines: external_exports.array(external_exports.string())\n }).strict();\n var jsonRpcMessageSchema = external_exports.custom(\n (value) => jsonRpcEnvelopeSchema.safeParse(value).success,\n \"Invalid JSON-RPC envelope\"\n );\n var replayRawProviderCaptureEntrySchema = external_exports.object({\n kind: external_exports.literal(\"raw-provider-event\"),\n capturedAt: external_exports.number().int().nonnegative(),\n providerId: external_exports.string().min(1),\n captureId: external_exports.string().min(1),\n rawLine: external_exports.string(),\n rawEvent: jsonRpcMessageSchema,\n sourceThreadId: external_exports.string().optional()\n });\n var replayCaptureTurnSchema = external_exports.object({\n turnId: external_exports.string().min(1),\n userInput: external_exports.array(promptInputSchema).min(1),\n createdAt: external_exports.number().int().nonnegative()\n }).strict();\n var replayCaptureEventCountsSchema = external_exports.object({\n rawProviderEvents: external_exports.number().int().nonnegative(),\n droppedRecords: external_exports.number().int().nonnegative()\n }).strict();\n var replayCaptureManifestSchema = external_exports.object({\n schemaVersion: external_exports.literal(REPLAY_CAPTURE_SCHEMA_VERSION),\n captureId: external_exports.string().regex(REPLAY_CAPTURE_ID_PATTERN),\n capturedAt: external_exports.number().int().nonnegative(),\n completedAt: external_exports.number().int().nonnegative().nullable(),\n source: replayCaptureSourceSchema,\n providerId: external_exports.string().min(1),\n projectId: external_exports.string().min(1),\n environmentId: external_exports.string().min(1),\n threadId: external_exports.string().min(1),\n /** Null means the provider did not emit a provider thread identity before the capture was read/finalized. */\n providerThreadId: external_exports.string().nullable(),\n title: external_exports.string().nullable(),\n kind: replayCaptureKindSchema,\n turns: external_exports.array(replayCaptureTurnSchema).min(1),\n userInputPreview: external_exports.string(),\n execution: resolvedThreadExecutionOptionsSchema,\n eventCounts: replayCaptureEventCountsSchema,\n errorMessage: external_exports.string().nullable()\n }).strict();\n var replayCaptureSummarySchema = replayCaptureManifestSchema.pick({\n captureId: true,\n capturedAt: true,\n completedAt: true,\n providerId: true,\n projectId: true,\n environmentId: true,\n threadId: true,\n title: true,\n kind: true,\n userInputPreview: true,\n execution: true,\n eventCounts: true,\n errorMessage: true\n });\n var replayCaptureHostSummarySchema = replayCaptureSummarySchema.extend(\n {\n hostId: external_exports.string().min(1),\n projectName: external_exports.string().nullable()\n }\n );\n var replayCaptureDaemonListResponseSchema = external_exports.object({\n captures: external_exports.array(replayCaptureSummarySchema)\n });\n var replayCaptureDetailSchema = replayCaptureManifestSchema.extend({\n hostId: external_exports.string().min(1),\n projectName: external_exports.string().nullable()\n });\n var replayCaptureListResponseSchema = external_exports.object({\n captures: external_exports.array(replayCaptureHostSummarySchema)\n });\n var replaySpeedSchema = external_exports.union([\n external_exports.literal(0.5),\n external_exports.literal(1),\n external_exports.literal(2),\n external_exports.literal(5),\n external_exports.literal(10)\n ]);\n var replayRunRequestSchema = external_exports.object({\n speed: replaySpeedSchema\n }).strict();\n var replayRunResponseSchema = external_exports.object({\n runId: external_exports.string(),\n replayThreadId: external_exports.string(),\n projectId: external_exports.string()\n });\n var replayRawProviderEventRecordSchema = external_exports.object({\n ordinal: external_exports.number().int().positive(),\n relativeMs: external_exports.number().int().nonnegative(),\n entry: replayRawProviderCaptureEntrySchema\n });\n\n // ../host-daemon-contract/src/commands.ts\n var INJECTED_SKILL_NAME_PATTERN = /^(?!.*--)[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$/u;\n var HOST_DAEMON_DURABLE_COMMAND_TYPES = [\n \"thread.start\",\n \"turn.submit\",\n \"thread.stop\",\n \"thread.rename\",\n \"thread.archive\",\n \"thread.unarchive\",\n \"thread.deleted\",\n \"interactive.resolve\",\n \"codex.inference.complete\",\n \"codex.voice.transcribe\",\n \"host.write_file_relative\",\n \"host.delete_file_relative\",\n \"host.delete_path_relative\",\n \"environment.provision\",\n \"environment.cleanup_preflight\",\n \"environment.destroy\",\n \"workspace.commit\",\n \"workspace.squash_merge\"\n ];\n var hostDaemonDurableCommandTypeSchema = external_exports.enum(\n HOST_DAEMON_DURABLE_COMMAND_TYPES\n );\n var hostDaemonCommandTypes = new Set(\n HOST_DAEMON_DURABLE_COMMAND_TYPES\n );\n function isHostDaemonDurableCommandType(type) {\n return hostDaemonCommandTypes.has(type);\n }\n var workspaceContextSchema = external_exports.object({\n workspacePath: external_exports.string().min(1),\n workspaceProvisionType: workspaceProvisionTypeSchema\n });\n var workspaceResolutionFailureCodeSchema = external_exports.enum([\n \"path_not_found\",\n \"not_git_repo\",\n \"not_worktree\",\n \"workspace_type_mismatch\",\n \"permission_denied\",\n \"unknown_environment\",\n \"unknown\"\n ]);\n var workspaceResolutionFailureSchema = external_exports.object({\n code: workspaceResolutionFailureCodeSchema,\n workspacePath: external_exports.string().min(1),\n message: external_exports.string().min(1)\n }).strict();\n var hostDaemonThreadTargetSchema = external_exports.object({\n environmentId: external_exports.string().min(1),\n threadId: external_exports.string().min(1)\n });\n var hostDaemonInjectedSkillSourceBaseSchema = external_exports.object({\n name: external_exports.string().max(64).regex(INJECTED_SKILL_NAME_PATTERN),\n description: external_exports.string().min(1).max(1024),\n sourceRootPath: external_exports.string().min(1),\n skillFilePath: external_exports.string().min(1)\n }).strict();\n var hostDaemonInjectedSkillSourceSchema = external_exports.discriminatedUnion(\n \"sourceType\",\n [\n hostDaemonInjectedSkillSourceBaseSchema.extend({\n sourceType: external_exports.literal(\"data-dir\"),\n applicationId: external_exports.null()\n }).strict(),\n hostDaemonInjectedSkillSourceBaseSchema.extend({\n sourceType: external_exports.literal(\"global-app\"),\n applicationId: applicationIdSchema\n }).strict()\n ]\n );\n var hostDaemonThreadRuntimeContextSchema = external_exports.object({\n workspaceContext: workspaceContextSchema,\n projectId: external_exports.string().min(1),\n providerId: external_exports.string().min(1),\n options: runtimeThreadExecutionOptionsSchema,\n instructions: external_exports.string().min(1),\n dynamicTools: external_exports.array(dynamicToolSchema),\n injectedSkillSources: external_exports.array(hostDaemonInjectedSkillSourceSchema),\n disallowedTools: external_exports.array(external_exports.string()).optional(),\n instructionMode: instructionModeSchema\n });\n var hostDaemonExistingThreadRuntimeContextSchema = hostDaemonThreadRuntimeContextSchema.extend({\n providerThreadId: external_exports.string().min(1)\n });\n var turnResumeContextSchema = hostDaemonExistingThreadRuntimeContextSchema.omit({\n options: true\n });\n var hostDaemonEnvironmentTargetSchema = external_exports.object({\n environmentId: external_exports.string().min(1)\n });\n var hostDaemonWorkspaceTargetSchema = hostDaemonEnvironmentTargetSchema.extend({\n workspaceContext: workspaceContextSchema\n });\n var hostDaemonThreadWorkspaceTargetSchema = hostDaemonThreadTargetSchema.extend({\n workspaceContext: workspaceContextSchema\n });\n var threadStartCommandSchema = hostDaemonThreadTargetSchema.merge(hostDaemonThreadRuntimeContextSchema).extend({\n type: external_exports.literal(\"thread.start\"),\n requestId: clientTurnRequestIdSchema,\n input: external_exports.array(promptInputSchema).min(1),\n threadStoragePath: external_exports.string().min(1).optional()\n }).strict();\n var turnSubmitTargetSchema = external_exports.discriminatedUnion(\"mode\", [\n external_exports.object({\n mode: external_exports.literal(\"start\")\n }),\n external_exports.object({\n mode: external_exports.literal(\"auto\"),\n expectedTurnId: external_exports.string().min(1).nullable()\n }),\n external_exports.object({\n mode: external_exports.literal(\"steer\"),\n expectedTurnId: external_exports.string().min(1).nullable()\n })\n ]);\n var turnSubmitCommandSchema = hostDaemonThreadTargetSchema.extend({\n type: external_exports.literal(\"turn.submit\"),\n requestId: clientTurnRequestIdSchema,\n input: external_exports.array(promptInputSchema).min(1),\n options: runtimeThreadExecutionOptionsSchema,\n resumeContext: turnResumeContextSchema,\n target: turnSubmitTargetSchema\n }).strict();\n var threadStopCommandSchema = hostDaemonThreadTargetSchema.extend({\n type: external_exports.literal(\"thread.stop\")\n });\n var threadRenameCommandSchema = hostDaemonThreadTargetSchema.extend({\n type: external_exports.literal(\"thread.rename\"),\n title: external_exports.string().min(1)\n });\n var threadArchiveCommandSchema = hostDaemonThreadWorkspaceTargetSchema.extend({\n type: external_exports.literal(\"thread.archive\"),\n providerId: external_exports.string().min(1),\n providerThreadId: external_exports.string().min(1)\n });\n var threadUnarchiveCommandSchema = hostDaemonThreadTargetSchema.extend({\n type: external_exports.literal(\"thread.unarchive\"),\n providerId: external_exports.string().min(1),\n providerThreadId: external_exports.string().min(1)\n });\n var threadDeletedCommandSchema = hostDaemonThreadTargetSchema.extend({\n type: external_exports.literal(\"thread.deleted\")\n });\n var interactiveResolveCommandSchema = hostDaemonThreadTargetSchema.extend({\n type: external_exports.literal(\"interactive.resolve\"),\n interactionId: external_exports.string().min(1),\n providerId: external_exports.string().min(1),\n providerThreadId: external_exports.string().min(1),\n providerRequestId: external_exports.string().min(1),\n resolution: pendingInteractionResolutionSchema\n });\n var codexInferenceCompleteCommandSchema = external_exports.object({\n type: external_exports.literal(\"codex.inference.complete\"),\n model: external_exports.string().min(1),\n prompt: external_exports.string().min(1),\n outputSchema: jsonObjectSchema,\n timeoutMs: external_exports.number().int().positive()\n }).strict();\n var codexVoiceTranscribeCommandSchema = external_exports.object({\n type: external_exports.literal(\"codex.voice.transcribe\"),\n model: external_exports.string().min(1),\n audioBase64: external_exports.string().min(1),\n mimeType: external_exports.string().min(1),\n filename: external_exports.string().min(1),\n prompt: external_exports.string().nullable(),\n timeoutMs: external_exports.number().int().positive()\n }).strict();\n var hostReadFileCommandSchema = external_exports.object({\n type: external_exports.literal(\"host.read_file\"),\n path: external_exports.string().min(1),\n rootPath: external_exports.string().min(1).optional(),\n ref: external_exports.string().min(1).optional()\n }).superRefine((command, context) => {\n if (command.ref !== void 0 && command.rootPath === void 0) {\n context.addIssue({\n code: \"custom\",\n path: [\"rootPath\"],\n message: \"rootPath is required when ref is set\"\n });\n }\n });\n var hostReadFileRelativeDotfilePolicySchema = external_exports.enum([\n \"allow\",\n \"deny\"\n ]);\n var hostReadFileRelativeCommandSchema = external_exports.object({\n type: external_exports.literal(\"host.read_file_relative\"),\n rootPath: external_exports.string().min(1),\n path: external_exports.string().min(1),\n dotfiles: hostReadFileRelativeDotfilePolicySchema\n }).strict();\n var hostWriteFileRelativeCommandSchema = external_exports.object({\n type: external_exports.literal(\"host.write_file_relative\"),\n rootPath: external_exports.string().min(1),\n path: external_exports.string().min(1),\n dotfiles: hostReadFileRelativeDotfilePolicySchema,\n content: external_exports.string(),\n contentEncoding: external_exports.enum([\"base64\", \"utf8\"])\n }).strict();\n var hostDeleteFileRelativeCommandSchema = external_exports.object({\n type: external_exports.literal(\"host.delete_file_relative\"),\n rootPath: external_exports.string().min(1),\n path: external_exports.string().min(1),\n dotfiles: hostReadFileRelativeDotfilePolicySchema\n }).strict();\n var hostDeletePathRelativeCommandSchema = external_exports.object({\n type: external_exports.literal(\"host.delete_path_relative\"),\n rootPath: external_exports.string().min(1),\n path: external_exports.string().min(1),\n dotfiles: hostReadFileRelativeDotfilePolicySchema\n }).strict();\n var hostFileMetadataCommandSchema = external_exports.object({\n type: external_exports.literal(\"host.file_metadata\"),\n path: external_exports.string().min(1),\n rootPath: external_exports.string().min(1).optional()\n }).strict();\n var hostListFilesCommandSchema = external_exports.object({\n type: external_exports.literal(\"host.list_files\"),\n path: external_exports.string().min(1),\n query: external_exports.string().max(FILE_LIST_QUERY_MAX_LENGTH).optional(),\n limit: external_exports.number().int().positive().max(FILE_LIST_LIMIT_MAX)\n });\n var hostPathEntryKindSchema = external_exports.enum([\"file\", \"directory\"]);\n var hostPathEntrySchema = external_exports.object({\n kind: hostPathEntryKindSchema,\n path: external_exports.string(),\n name: external_exports.string(),\n score: external_exports.number(),\n positions: external_exports.array(external_exports.number().int().nonnegative())\n });\n var hostListPathsCommandSchema = external_exports.object({\n type: external_exports.literal(\"host.list_paths\"),\n path: external_exports.string().min(1),\n query: external_exports.string().max(FILE_LIST_QUERY_MAX_LENGTH).optional(),\n limit: external_exports.number().int().positive().max(FILE_LIST_LIMIT_MAX),\n includeFiles: external_exports.boolean(),\n includeDirectories: external_exports.boolean()\n }).refine((command) => command.includeFiles || command.includeDirectories, {\n message: \"At least one path kind must be included\"\n });\n var hostListBranchesCommandSchema = external_exports.object({\n type: external_exports.literal(\"host.list_branches\"),\n path: external_exports.string().min(1),\n query: external_exports.string().max(BRANCH_LIST_QUERY_MAX_LENGTH).optional(),\n selectedBranch: gitBranchNameSchema.optional(),\n limit: external_exports.number().int().positive().max(BRANCH_LIST_LIMIT_MAX)\n });\n var providerListCommandSchema = external_exports.object({\n type: external_exports.literal(\"provider.list\")\n });\n var providerListModelsCommandSchema = external_exports.object({\n type: external_exports.literal(\"provider.list_models\"),\n providerId: external_exports.string().min(1)\n });\n var provisionInitiatorSchema = external_exports.object({\n /** Thread that initiated provisioning. Used to stream progress events. */\n threadId: external_exports.string().min(1),\n /** Stable provisioning lifecycle rendered by streamed progress events. */\n provisioningId: external_exports.string().min(1)\n }).strict();\n var environmentProvisionCommandBaseSchema = hostDaemonEnvironmentTargetSchema.extend({\n type: external_exports.literal(\"environment.provision\"),\n /** Initiating thread for live progress streaming. Null when no thread is associated (e.g., project source provisioning). */\n initiator: provisionInitiatorSchema.nullable()\n });\n var unmanagedCheckoutSchema = external_exports.discriminatedUnion(\"kind\", [\n external_exports.object({\n kind: external_exports.literal(\"existing\"),\n name: gitBranchNameSchema\n }).strict(),\n external_exports.object({\n kind: external_exports.literal(\"new\"),\n name: gitBranchNameSchema,\n baseBranch: gitBranchNameSchema\n }).strict()\n ]);\n var unmanagedEnvironmentProvisionCommandSchema = environmentProvisionCommandBaseSchema.extend({\n workspaceProvisionType: external_exports.literal(\"unmanaged\"),\n /** Path to validate */\n path: external_exports.string().min(1),\n /** When set, the daemon checks out this branch before opening the workspace. */\n checkout: unmanagedCheckoutSchema.optional()\n });\n var managedEnvironmentProvisionFieldsSchema = external_exports.object({\n /** Source repo path */\n sourcePath: external_exports.string().min(1),\n /** Target path for worktree/clone creation */\n targetPath: external_exports.string().min(1),\n /** Name of the new branch the daemon should create for this environment. */\n branchName: gitBranchNameSchema,\n /**\n * Branch on the source repo that the new branch should be based on. Pass\n * `null` to use the source's default branch (resolved by the daemon).\n */\n baseBranch: gitBranchNameSchema.nullable(),\n /** Maximum time in ms to wait for the setup script */\n setupTimeoutMs: external_exports.number().int().positive()\n });\n var managedWorktreeEnvironmentProvisionCommandSchema = environmentProvisionCommandBaseSchema.merge(managedEnvironmentProvisionFieldsSchema).extend({ workspaceProvisionType: external_exports.literal(\"managed-worktree\") });\n var personalEnvironmentProvisionCommandSchema = environmentProvisionCommandBaseSchema.extend({\n workspaceProvisionType: external_exports.literal(\"personal\"),\n /** Target directory under the host data dir for the personal workspace. */\n targetPath: external_exports.string().min(1)\n });\n var environmentProvisionCommandSchema = external_exports.discriminatedUnion(\n \"workspaceProvisionType\",\n [\n unmanagedEnvironmentProvisionCommandSchema,\n managedWorktreeEnvironmentProvisionCommandSchema,\n personalEnvironmentProvisionCommandSchema\n ]\n );\n var environmentDestroyCommandSchema = hostDaemonWorkspaceTargetSchema.extend({\n type: external_exports.literal(\"environment.destroy\")\n });\n var environmentCleanupPreflightCommandSchema = hostDaemonWorkspaceTargetSchema.extend({\n type: external_exports.literal(\"environment.cleanup_preflight\"),\n mergeBaseBranch: gitBranchNameSchema\n });\n var workspaceStatusCommandSchema = hostDaemonWorkspaceTargetSchema.extend({\n type: external_exports.literal(\"workspace.status\"),\n mergeBaseBranch: gitBranchNameSchema.optional()\n });\n var workspaceDiffCommandSchema = hostDaemonWorkspaceTargetSchema.extend({\n type: external_exports.literal(\"workspace.diff\"),\n target: workspaceDiffTargetSchema,\n maxDiffBytes: external_exports.number().int().positive(),\n maxFileListBytes: external_exports.number().int().positive()\n });\n var HOST_DAEMON_ONLINE_RPC_COMMAND_TYPES = [\n \"development.replay\",\n \"host.list_files\",\n \"host.list_paths\",\n \"host.list_branches\",\n \"host.file_metadata\",\n \"host.read_file\",\n \"host.read_file_relative\",\n \"provider.list\",\n \"provider.list_models\",\n \"workspace.status\",\n \"workspace.diff\"\n ];\n var hostDaemonOnlineRpcCommandTypeSchema = external_exports.enum(\n HOST_DAEMON_ONLINE_RPC_COMMAND_TYPES\n );\n var developmentReplaySpeedSchema = external_exports.union([\n external_exports.literal(0.5),\n external_exports.literal(1),\n external_exports.literal(2),\n external_exports.literal(5),\n external_exports.literal(10)\n ]);\n var developmentReplayCommandSchema = external_exports.discriminatedUnion(\n \"operation\",\n [\n external_exports.object({\n type: external_exports.literal(\"development.replay\"),\n operation: external_exports.literal(\"capture-list\")\n }).strict(),\n external_exports.object({\n type: external_exports.literal(\"development.replay\"),\n operation: external_exports.literal(\"capture-get\"),\n captureId: external_exports.string().min(1)\n }).strict(),\n external_exports.object({\n type: external_exports.literal(\"development.replay\"),\n operation: external_exports.literal(\"capture-delete\"),\n captureId: external_exports.string().min(1)\n }).strict(),\n hostDaemonThreadTargetSchema.extend({\n type: external_exports.literal(\"development.replay\"),\n operation: external_exports.literal(\"run\"),\n captureId: external_exports.string().min(1),\n requestId: clientTurnRequestIdSchema,\n speed: developmentReplaySpeedSchema\n }).strict()\n ]\n );\n var hostDaemonOnlineRpcCommandSchema = external_exports.union([\n developmentReplayCommandSchema,\n hostListFilesCommandSchema,\n hostListPathsCommandSchema,\n hostListBranchesCommandSchema,\n hostFileMetadataCommandSchema,\n hostReadFileCommandSchema,\n hostReadFileRelativeCommandSchema,\n providerListCommandSchema,\n providerListModelsCommandSchema,\n workspaceStatusCommandSchema,\n workspaceDiffCommandSchema\n ]);\n var hostDaemonRetryableOnlineRpcCommandSchema = external_exports.union([\n hostListFilesCommandSchema,\n hostListPathsCommandSchema,\n hostListBranchesCommandSchema,\n hostFileMetadataCommandSchema,\n hostReadFileCommandSchema,\n hostReadFileRelativeCommandSchema,\n providerListCommandSchema,\n providerListModelsCommandSchema,\n workspaceStatusCommandSchema,\n workspaceDiffCommandSchema\n ]);\n var workspaceCommitCommandSchema = hostDaemonWorkspaceTargetSchema.extend({\n type: external_exports.literal(\"workspace.commit\"),\n message: external_exports.string().min(1)\n });\n var workspaceSquashMergeCommandSchema = hostDaemonWorkspaceTargetSchema.extend(\n {\n type: external_exports.literal(\"workspace.squash_merge\"),\n targetBranch: gitBranchNameSchema,\n commitMessage: external_exports.string().min(1)\n }\n );\n var hostDaemonNonProvisionCommandSchema = external_exports.discriminatedUnion(\"type\", [\n threadStartCommandSchema,\n turnSubmitCommandSchema,\n threadStopCommandSchema,\n threadRenameCommandSchema,\n threadArchiveCommandSchema,\n threadUnarchiveCommandSchema,\n threadDeletedCommandSchema,\n interactiveResolveCommandSchema,\n codexInferenceCompleteCommandSchema,\n codexVoiceTranscribeCommandSchema,\n hostWriteFileRelativeCommandSchema,\n hostDeleteFileRelativeCommandSchema,\n hostDeletePathRelativeCommandSchema,\n environmentCleanupPreflightCommandSchema,\n environmentDestroyCommandSchema,\n workspaceCommitCommandSchema,\n workspaceSquashMergeCommandSchema\n ]);\n var hostDaemonCommandSchema = external_exports.union([\n hostDaemonNonProvisionCommandSchema,\n environmentProvisionCommandSchema\n ]);\n var fileReadResultSchema = external_exports.object({\n path: external_exports.string(),\n content: external_exports.string(),\n contentEncoding: external_exports.enum([\"base64\", \"utf8\"]),\n mimeType: external_exports.string().optional(),\n sizeBytes: external_exports.number().int().nonnegative(),\n modifiedAtMs: external_exports.number().nonnegative().optional()\n });\n var fileMetadataResultSchema = external_exports.object({\n path: external_exports.string(),\n modifiedAtMs: external_exports.number().nonnegative(),\n sizeBytes: external_exports.number().int().nonnegative()\n });\n var fileWriteResultSchema = external_exports.object({\n path: external_exports.string(),\n hash: external_exports.string().min(1),\n modifiedAtMs: external_exports.number().nonnegative(),\n sizeBytes: external_exports.number().int().nonnegative()\n });\n var fileDeleteResultSchema = external_exports.object({\n path: external_exports.string(),\n deleted: external_exports.boolean(),\n previousHash: external_exports.string().nullable()\n });\n var pathDeleteResultSchema = external_exports.object({\n path: external_exports.string(),\n deleted: external_exports.boolean()\n });\n var environmentCleanupPreflightResultSchema = external_exports.discriminatedUnion(\n \"outcome\",\n [\n external_exports.object({ outcome: external_exports.literal(\"safe_to_destroy\") }).strict(),\n external_exports.object({\n outcome: external_exports.literal(\"blocked_by_changes\"),\n message: external_exports.string().min(1)\n }).strict(),\n external_exports.object({\n outcome: external_exports.literal(\"already_missing\"),\n failure: workspaceResolutionFailureSchema\n }).strict(),\n external_exports.object({\n outcome: external_exports.literal(\"not_inspectable\"),\n failure: workspaceResolutionFailureSchema\n }).strict(),\n external_exports.object({\n outcome: external_exports.literal(\"probe_failed\"),\n failure: workspaceResolutionFailureSchema\n }).strict()\n ]\n );\n var workspaceStatusResultSchema = external_exports.discriminatedUnion(\"outcome\", [\n external_exports.object({\n outcome: external_exports.literal(\"available\"),\n workspaceStatus: workspaceStatusSchema\n }).strict(),\n external_exports.object({\n outcome: external_exports.literal(\"unavailable\"),\n failure: workspaceResolutionFailureSchema\n }).strict()\n ]);\n var workspaceDiffResultSchema = external_exports.discriminatedUnion(\"outcome\", [\n external_exports.object({\n outcome: external_exports.literal(\"available\"),\n diff: threadGitDiffResponseSchema\n }).strict(),\n external_exports.object({\n outcome: external_exports.literal(\"unavailable\"),\n failure: workspaceResolutionFailureSchema\n }).strict()\n ]);\n var fileListResultSchema = external_exports.object({\n files: external_exports.array(external_exports.object({ path: external_exports.string(), name: external_exports.string() })),\n truncated: external_exports.boolean()\n });\n var pathListResultSchema = external_exports.object({\n paths: external_exports.array(hostPathEntrySchema),\n truncated: external_exports.boolean()\n });\n var providerListResultSchema = external_exports.object({\n providers: external_exports.array(providerInfoSchema)\n });\n var providerListModelsResultSchema = external_exports.object({\n models: external_exports.array(availableModelSchema),\n selectedOnlyModels: external_exports.array(availableModelSchema)\n });\n var hostDaemonCommandResultSchemaByType = {\n \"thread.start\": external_exports.object({\n providerThreadId: external_exports.string().min(1)\n }),\n \"turn.submit\": external_exports.object({\n appliedAs: external_exports.enum([\"new-turn\", \"steer\"])\n }),\n \"thread.stop\": external_exports.object({}),\n \"thread.rename\": external_exports.object({}),\n \"thread.archive\": external_exports.object({}),\n \"thread.unarchive\": external_exports.object({}),\n \"thread.deleted\": external_exports.object({}),\n \"interactive.resolve\": external_exports.object({}),\n \"codex.inference.complete\": external_exports.object({\n model: external_exports.string().min(1),\n value: jsonObjectSchema\n }),\n \"codex.voice.transcribe\": external_exports.object({\n model: external_exports.string().min(1),\n text: external_exports.string()\n }),\n \"host.write_file_relative\": fileWriteResultSchema,\n \"host.delete_file_relative\": fileDeleteResultSchema,\n \"host.delete_path_relative\": pathDeleteResultSchema,\n \"environment.provision\": discoveredWorkspacePropertiesSchema.extend({\n transcript: external_exports.array(provisioningTranscriptEntrySchema)\n }),\n \"environment.cleanup_preflight\": environmentCleanupPreflightResultSchema,\n \"environment.destroy\": external_exports.object({}),\n \"workspace.commit\": external_exports.object({\n commitSha: external_exports.string().min(1),\n commitSubject: external_exports.string().min(1)\n }),\n \"workspace.squash_merge\": external_exports.object({\n merged: external_exports.boolean(),\n commitSha: external_exports.string().min(1),\n commitSubject: external_exports.string().min(1)\n })\n };\n var emptyReplayResultSchema = external_exports.object({}).strict();\n var developmentReplayResultSchemaByOperation = {\n \"capture-list\": replayCaptureDaemonListResponseSchema,\n \"capture-get\": replayCaptureManifestSchema,\n \"capture-delete\": emptyReplayResultSchema,\n run: emptyReplayResultSchema\n };\n var developmentReplayResultSchema = external_exports.union([\n developmentReplayResultSchemaByOperation[\"capture-list\"],\n developmentReplayResultSchemaByOperation[\"capture-get\"],\n developmentReplayResultSchemaByOperation[\"capture-delete\"]\n ]);\n var hostDaemonOnlineRpcResultSchemaByType = {\n \"development.replay\": developmentReplayResultSchema,\n \"host.list_files\": fileListResultSchema,\n \"host.list_paths\": pathListResultSchema,\n \"host.file_metadata\": fileMetadataResultSchema,\n \"host.list_branches\": projectSourceCheckoutSchema,\n \"host.read_file\": fileReadResultSchema,\n \"host.read_file_relative\": fileReadResultSchema,\n \"provider.list\": providerListResultSchema,\n \"provider.list_models\": providerListModelsResultSchema,\n \"workspace.status\": workspaceStatusResultSchema,\n \"workspace.diff\": workspaceDiffResultSchema\n };\n var hostDaemonCommandEnvelopeSchema = external_exports.object({\n id: external_exports.string().min(1),\n attemptId: external_exports.string().min(1),\n cursor: external_exports.number().int().nonnegative(),\n command: hostDaemonCommandSchema\n });\n var hostDaemonCommandResultReportBaseSchema = external_exports.object({\n sessionId: external_exports.string().min(1),\n commandId: external_exports.string().min(1),\n attemptId: external_exports.string().min(1),\n completedAt: external_exports.number().int().nonnegative()\n });\n function createHostDaemonCommandResultReportSchemasForType(type, resultSchema) {\n return [\n hostDaemonCommandResultReportBaseSchema.extend({\n type: external_exports.literal(type),\n ok: external_exports.literal(true),\n result: resultSchema\n }),\n hostDaemonCommandResultReportBaseSchema.extend({\n type: external_exports.literal(type),\n ok: external_exports.literal(false),\n errorCode: external_exports.string().min(1),\n errorMessage: external_exports.string().min(1)\n })\n ];\n }\n function createKnownHostDaemonCommandResultReportSchemaForType(type) {\n return external_exports.discriminatedUnion(\n \"ok\",\n createHostDaemonCommandResultReportSchemasForType(\n type,\n hostDaemonCommandResultSchemaByType[type]\n )\n );\n }\n var unknownCommandErrorSchema = hostDaemonCommandResultReportBaseSchema.extend({\n type: external_exports.string().min(1),\n ok: external_exports.literal(false),\n errorCode: external_exports.literal(\"unknown_command\"),\n errorMessage: external_exports.string().min(1)\n });\n var hostDaemonCommandResultReportEnvelopeSchema = hostDaemonCommandResultReportBaseSchema.extend({\n type: external_exports.string().min(1),\n ok: external_exports.boolean()\n });\n var knownHostDaemonCommandResultReportSchemasByType = new Map(\n HOST_DAEMON_DURABLE_COMMAND_TYPES.map((type) => [\n type,\n createKnownHostDaemonCommandResultReportSchemaForType(type)\n ])\n );\n var hostDaemonCommandResultReportSchema = external_exports.custom((value) => {\n const envelope = hostDaemonCommandResultReportEnvelopeSchema.safeParse(value);\n if (!envelope.success) {\n return false;\n }\n if (!isHostDaemonDurableCommandType(envelope.data.type)) {\n return unknownCommandErrorSchema.safeParse(value).success;\n }\n const schema = knownHostDaemonCommandResultReportSchemasByType.get(\n envelope.data.type\n );\n if (!schema) {\n return false;\n }\n return schema.safeParse(value).success;\n });\n\n // ../host-daemon-contract/src/session.ts\n var nonNegativeIntegerStringSchema = external_exports.string().regex(/^\\d+$/);\n var hostDaemonActiveThreadSchema = external_exports.object({\n threadId: external_exports.string().min(1)\n });\n var hostDaemonLoadedEnvironmentSchema = external_exports.object({\n environmentId: external_exports.string().min(1)\n });\n var hostDaemonTrackedThreadTargetSchema = external_exports.object({\n environmentId: external_exports.string().min(1),\n threadId: external_exports.string().min(1)\n });\n var hostDaemonTrackedApplicationDataTargetSchema = external_exports.object({\n applicationId: applicationIdSchema,\n appDataPath: external_exports.string().min(1)\n });\n var hostDaemonSessionOpenRequestSchema = external_exports.object({\n hostId: external_exports.string().min(1),\n instanceId: external_exports.string().min(1),\n hostName: external_exports.string().min(1),\n hostType: hostTypeSchema,\n dataDir: external_exports.string().min(1),\n // Accept any version at the schema boundary so the server can return an\n // actionable protocol mismatch instead of an opaque validation failure.\n protocolVersion: external_exports.number().int().positive(),\n activeThreads: external_exports.array(hostDaemonActiveThreadSchema),\n loadedEnvironments: external_exports.array(hostDaemonLoadedEnvironmentSchema).default([])\n });\n var hostDaemonEnrollRequestSchema = external_exports.object({\n hostId: external_exports.string().min(1),\n hostName: external_exports.string().min(1),\n hostType: hostTypeSchema\n }).strict();\n var hostDaemonEnrollResponseSchema = external_exports.object({\n hostId: external_exports.string().min(1),\n hostKey: external_exports.string().min(1)\n }).strict();\n var hostDaemonSessionOpenResponseSchema = external_exports.object({\n sessionId: external_exports.string().min(1),\n heartbeatIntervalMs: external_exports.number().int().positive(),\n leaseTimeoutMs: external_exports.number().int().positive(),\n trackedThreadTargets: external_exports.array(hostDaemonTrackedThreadTargetSchema),\n trackedApplicationDataTargets: external_exports.array(\n hostDaemonTrackedApplicationDataTargetSchema\n ),\n retiredEnvironmentIds: external_exports.array(external_exports.string().min(1)).default([])\n }).strict();\n var hostDaemonCommandsQuerySchema = external_exports.object({\n sessionId: external_exports.string().min(1),\n limit: nonNegativeIntegerStringSchema,\n waitMs: nonNegativeIntegerStringSchema\n });\n var hostDaemonProjectAttachmentContentQuerySchema = external_exports.object({\n sessionId: external_exports.string().min(1),\n threadId: external_exports.string().min(1),\n projectId: external_exports.string().min(1),\n path: external_exports.string().min(1)\n });\n var hostDaemonCommandBatchSchema = external_exports.object({\n commands: external_exports.array(hostDaemonCommandEnvelopeSchema)\n });\n var hostDaemonEventEnvelopeSchema = external_exports.object({\n producerEventId: hostDaemonProducerEventIdSchema,\n threadId: external_exports.string().min(1),\n event: threadEventSchema\n }).strict();\n var hostDaemonEventBatchRequestSchema = external_exports.object({\n sessionId: external_exports.string().min(1),\n events: external_exports.array(hostDaemonEventEnvelopeSchema)\n });\n var hostDaemonEventRejectionReasonSchema = external_exports.enum([\n \"thread_not_owned_by_host\"\n ]);\n var hostDaemonRejectedEventSchema = external_exports.object({\n producerEventId: hostDaemonProducerEventIdSchema,\n threadId: external_exports.string().min(1),\n reason: hostDaemonEventRejectionReasonSchema\n }).strict();\n var hostDaemonEventBatchResponseSchema = external_exports.object({\n acceptedEvents: external_exports.array(\n external_exports.object({\n producerEventId: hostDaemonProducerEventIdSchema,\n threadId: external_exports.string().min(1),\n sequence: external_exports.number().int().nonnegative()\n }).strict()\n ),\n rejectedEvents: external_exports.array(hostDaemonRejectedEventSchema)\n }).strict();\n var hostDaemonCommandResultResponseSchema = external_exports.object({\n ok: external_exports.literal(true)\n }).strict();\n var hostDaemonEnvironmentChangeSchema = external_exports.enum(ENVIRONMENT_CHANGE_KINDS).extract([\n \"work-status-changed\",\n \"git-refs-changed\",\n \"thread-storage-changed\"\n ]);\n var hostDaemonEnvironmentChangePayloadSchema = external_exports.object({\n environmentId: external_exports.string().min(1),\n change: hostDaemonEnvironmentChangeSchema\n });\n var hostDaemonAppDataChangePayloadBaseSchema = external_exports.object({\n applicationId: applicationIdSchema,\n path: appDataPathSchema,\n value: jsonValueSchema.nullable(),\n deleted: external_exports.boolean(),\n version: external_exports.string().min(1).nullable()\n }).strict();\n function validateHostDaemonAppDataChangePayload(payload, context) {\n if (payload.deleted && payload.version !== null) {\n context.addIssue({\n code: \"custom\",\n path: [\"version\"],\n message: \"version must be null for deleted app data changes\"\n });\n }\n if (!payload.deleted && payload.version === null) {\n context.addIssue({\n code: \"custom\",\n path: [\"version\"],\n message: \"version is required for non-deleted app data changes\"\n });\n }\n }\n var hostDaemonAppDataChangePayloadSchema = hostDaemonAppDataChangePayloadBaseSchema.superRefine(\n validateHostDaemonAppDataChangePayload\n );\n var hostDaemonAppDataChangeRequestSchema = external_exports.object({\n sessionId: external_exports.string().min(1),\n ...hostDaemonAppDataChangePayloadBaseSchema.shape\n }).strict().superRefine(validateHostDaemonAppDataChangePayload);\n var hostDaemonAppDataResyncPayloadSchema = external_exports.object({\n applicationId: applicationIdSchema\n }).strict();\n var hostDaemonAppDataResyncRequestSchema = hostDaemonAppDataResyncPayloadSchema.extend({\n sessionId: external_exports.string().min(1)\n }).strict();\n var hostDaemonSessionCloseReasonSchema = external_exports.enum([\n \"replaced\",\n \"expired\",\n \"daemon-disconnect\"\n ]);\n var terminalIdSchema = external_exports.string().min(1);\n var terminalRequestIdSchema = external_exports.string().min(1);\n var terminalCloseReasonSchema = external_exports.enum([\n \"user\",\n \"process-exit\",\n \"daemon-disconnect\",\n \"environment-destroyed\",\n \"thread-archived\",\n \"thread-deleted\",\n \"open-timeout\"\n ]);\n var hostDaemonOnlineRpcRequestIdSchema = external_exports.string().min(1);\n var hostDaemonOnlineRpcRequestMessageSchema = external_exports.object({\n type: external_exports.literal(\"host-rpc.request\"),\n requestId: hostDaemonOnlineRpcRequestIdSchema,\n command: hostDaemonOnlineRpcCommandSchema\n }).strict();\n var hostDaemonOnlineRpcResponseSuccessBaseSchema = external_exports.object({\n type: external_exports.literal(\"host-rpc.response\"),\n requestId: hostDaemonOnlineRpcRequestIdSchema,\n ok: external_exports.literal(true)\n }).strict();\n function rpcResponseSuccessSchemaFor(commandType) {\n return hostDaemonOnlineRpcResponseSuccessBaseSchema.extend({\n commandType: external_exports.literal(commandType),\n result: hostDaemonOnlineRpcResultSchemaByType[commandType]\n });\n }\n var hostDaemonOnlineRpcResponseSuccessSchema = external_exports.discriminatedUnion(\n \"commandType\",\n [\n rpcResponseSuccessSchemaFor(\"development.replay\"),\n rpcResponseSuccessSchemaFor(\"host.list_files\"),\n rpcResponseSuccessSchemaFor(\"host.list_paths\"),\n rpcResponseSuccessSchemaFor(\"host.file_metadata\"),\n rpcResponseSuccessSchemaFor(\"host.list_branches\"),\n rpcResponseSuccessSchemaFor(\"host.read_file\"),\n rpcResponseSuccessSchemaFor(\"host.read_file_relative\"),\n rpcResponseSuccessSchemaFor(\"provider.list\"),\n rpcResponseSuccessSchemaFor(\"provider.list_models\"),\n rpcResponseSuccessSchemaFor(\"workspace.status\"),\n rpcResponseSuccessSchemaFor(\"workspace.diff\")\n ]\n );\n var hostDaemonOnlineRpcResponseFailureSchema = external_exports.object({\n type: external_exports.literal(\"host-rpc.response\"),\n requestId: hostDaemonOnlineRpcRequestIdSchema,\n commandType: hostDaemonOnlineRpcCommandTypeSchema,\n ok: external_exports.literal(false),\n errorCode: external_exports.string().min(1),\n errorMessage: external_exports.string().min(1)\n }).strict();\n var hostDaemonOnlineRpcResponseMessageSchema = external_exports.union([\n hostDaemonOnlineRpcResponseSuccessSchema,\n hostDaemonOnlineRpcResponseFailureSchema\n ]);\n var hostDaemonTerminalOutputChunkSchema = external_exports.object({\n seq: external_exports.number().int().nonnegative(),\n dataBase64: terminalDataBase64Schema\n }).strict();\n var hostDaemonTerminalOpenMessageSchema = external_exports.object({\n type: external_exports.literal(\"terminal.open\"),\n requestId: terminalRequestIdSchema,\n terminalId: terminalIdSchema,\n threadId: external_exports.string().min(1),\n environmentId: external_exports.string().min(1),\n workspaceContext: workspaceContextSchema,\n cols: terminalColsSchema,\n rows: terminalRowsSchema\n }).strict();\n var hostDaemonTerminalAttachMessageSchema = external_exports.object({\n type: external_exports.literal(\"terminal.attach\"),\n requestId: terminalRequestIdSchema,\n terminalId: terminalIdSchema,\n sinceSeq: external_exports.number().int().nonnegative()\n }).strict();\n var hostDaemonTerminalInputMessageSchema = external_exports.object({\n type: external_exports.literal(\"terminal.input\"),\n terminalId: terminalIdSchema,\n dataBase64: terminalDataBase64Schema\n }).strict();\n var hostDaemonTerminalResizeMessageSchema = external_exports.object({\n type: external_exports.literal(\"terminal.resize\"),\n terminalId: terminalIdSchema,\n cols: terminalColsSchema,\n rows: terminalRowsSchema\n }).strict();\n var hostDaemonTerminalCloseMessageSchema = external_exports.object({\n type: external_exports.literal(\"terminal.close\"),\n terminalId: terminalIdSchema,\n reason: terminalCloseReasonSchema\n }).strict();\n var hostDaemonServerWsMessageSchema = external_exports.discriminatedUnion(\"type\", [\n external_exports.object({\n type: external_exports.literal(\"commands-available\")\n }).strict(),\n external_exports.object({\n type: external_exports.literal(\"session-close\"),\n reason: hostDaemonSessionCloseReasonSchema\n }).strict(),\n hostDaemonOnlineRpcRequestMessageSchema,\n hostDaemonTerminalOpenMessageSchema,\n hostDaemonTerminalAttachMessageSchema,\n hostDaemonTerminalInputMessageSchema,\n hostDaemonTerminalResizeMessageSchema,\n hostDaemonTerminalCloseMessageSchema\n ]);\n var hostDaemonHeartbeatMessageSchema = external_exports.object({\n type: external_exports.literal(\"heartbeat\")\n }).strict();\n var hostDaemonEnvironmentChangeMessageSchema = hostDaemonEnvironmentChangePayloadSchema.extend({\n type: external_exports.literal(\"environment-change\")\n }).strict();\n var hostDaemonApplicationStorageChangedMessageSchema = external_exports.object({\n type: external_exports.literal(\"application-storage-changed\")\n }).strict();\n var hostDaemonApplicationContentChangedMessageSchema = external_exports.object({\n type: external_exports.literal(\"application-content-changed\"),\n applicationId: applicationIdSchema\n }).strict();\n var hostDaemonTerminalOpenedMessageSchema = external_exports.object({\n type: external_exports.literal(\"terminal.opened\"),\n requestId: terminalRequestIdSchema,\n terminalId: terminalIdSchema,\n shell: external_exports.string().min(1),\n title: external_exports.string().min(1),\n initialCwd: external_exports.string().min(1),\n currentCwd: external_exports.string().min(1).nullable(),\n cols: terminalColsSchema,\n rows: terminalRowsSchema\n }).strict();\n var hostDaemonTerminalOutputMessageSchema = external_exports.object({\n type: external_exports.literal(\"terminal.output\"),\n terminalId: terminalIdSchema,\n chunk: hostDaemonTerminalOutputChunkSchema\n }).strict();\n var hostDaemonTerminalReplayMessageSchema = external_exports.object({\n type: external_exports.literal(\"terminal.replay\"),\n requestId: terminalRequestIdSchema,\n terminalId: terminalIdSchema,\n chunks: external_exports.array(hostDaemonTerminalOutputChunkSchema),\n nextSeq: external_exports.number().int().nonnegative()\n }).strict();\n var hostDaemonTerminalExitedMessageSchema = external_exports.object({\n type: external_exports.literal(\"terminal.exited\"),\n terminalId: terminalIdSchema,\n exitCode: external_exports.number().int().nullable(),\n closeReason: terminalCloseReasonSchema\n }).strict();\n var hostDaemonTerminalErrorMessageSchema = external_exports.object({\n type: external_exports.literal(\"terminal.error\"),\n requestId: terminalRequestIdSchema,\n terminalId: terminalIdSchema,\n code: external_exports.string().min(1),\n message: external_exports.string().min(1)\n }).strict();\n var hostDaemonDaemonWsMessageSchema = external_exports.union([\n hostDaemonHeartbeatMessageSchema,\n hostDaemonEnvironmentChangeMessageSchema,\n hostDaemonApplicationStorageChangedMessageSchema,\n hostDaemonApplicationContentChangedMessageSchema,\n hostDaemonTerminalOpenedMessageSchema,\n hostDaemonTerminalOutputMessageSchema,\n hostDaemonTerminalReplayMessageSchema,\n hostDaemonTerminalExitedMessageSchema,\n hostDaemonTerminalErrorMessageSchema,\n hostDaemonOnlineRpcResponseMessageSchema\n ]);\n var hostDaemonToolCallRequestSchema = toolCallRequestSchema.pick({\n threadId: true,\n providerThreadId: true,\n turnId: true,\n callId: true,\n tool: true,\n arguments: true\n }).extend({\n sessionId: external_exports.string().min(1)\n });\n var hostDaemonInteractiveRequestSchema = external_exports.object({\n sessionId: external_exports.string().min(1),\n interaction: pendingInteractionCreateSchema\n });\n var hostDaemonInteractiveRequestResponseSchema = external_exports.discriminatedUnion(\n \"outcome\",\n [\n external_exports.object({\n outcome: external_exports.literal(\"created\"),\n interactionId: external_exports.string().min(1),\n status: pendingInteractionStatusSchema\n }),\n external_exports.object({\n outcome: external_exports.literal(\"existing\"),\n interactionId: external_exports.string().min(1),\n status: pendingInteractionStatusSchema\n }),\n external_exports.object({\n outcome: external_exports.literal(\"rejected\"),\n reason: external_exports.string().min(1)\n })\n ]\n );\n var hostDaemonInteractiveInterruptRequestSchema = external_exports.object({\n sessionId: external_exports.string().min(1),\n providerId: external_exports.string().min(1),\n threadIds: external_exports.array(external_exports.string().min(1)).min(1),\n reason: external_exports.string().min(1)\n });\n var hostDaemonInteractiveInterruptResponseSchema = external_exports.object({\n ok: external_exports.literal(true),\n interactionIds: external_exports.array(external_exports.string().min(1))\n });\n\n // ../server-contract/src/api-types.ts\n var sendMessageModeSchema = external_exports.enum([\"auto\", \"start\", \"steer\"]);\n var AUTOMATION_NAME_MAX_LENGTH = 200;\n var SCHEDULE_CRON_MAX_LENGTH = 100;\n var SCHEDULE_NAME_MAX_LENGTH = 200;\n var SCHEDULE_TIMEZONE_MAX_LENGTH = 100;\n function isCommaSeparatedIncludeQueryValue(args) {\n const requestedValues = args.value.split(\",\");\n return requestedValues.every(\n (value) => value.length > 0 && args.allowedValues.includes(value)\n );\n }\n var threadContextWindowUsageSchema = external_exports.object({\n usedTokens: external_exports.number(),\n modelContextWindow: external_exports.number(),\n estimated: external_exports.boolean()\n });\n var isoUtcDateTimeSchema = external_exports.iso.datetime();\n var bbDesktopVersionFeedFileSchema = external_exports.object({\n url: external_exports.string().min(1),\n sha512: external_exports.string().min(1),\n size: external_exports.number().int().nonnegative()\n });\n var bbDesktopVersionFeedSchema = external_exports.object({\n schemaVersion: external_exports.literal(1),\n channel: external_exports.literal(\"latest\"),\n platform: external_exports.literal(\"macos\"),\n version: external_exports.string().min(1),\n releaseDate: isoUtcDateTimeSchema,\n releaseName: external_exports.string().min(1),\n releaseNotes: external_exports.string().nullable(),\n minimumSystemVersion: external_exports.string().min(1).nullable(),\n files: external_exports.array(bbDesktopVersionFeedFileSchema).min(1),\n path: external_exports.string().min(1),\n sha512: external_exports.string().min(1),\n stagingPercentage: external_exports.number().min(0).max(100).nullable()\n });\n var bbDesktopInfoSchema = external_exports.object({\n lastCheckedAt: isoUtcDateTimeSchema.nullable(),\n latestVersion: external_exports.string().min(1).nullable(),\n pendingVersion: external_exports.string().min(1).nullable(),\n platform: external_exports.literal(\"macos\"),\n updateAvailable: external_exports.boolean(),\n updateDownloaded: external_exports.boolean(),\n version: external_exports.string().min(1)\n });\n var bbDesktopThemeSchema = external_exports.enum([\"light\", \"dark\"]);\n var BB_DESKTOP_BROWSER_MAX_URL_LENGTH = 4096;\n var BB_DESKTOP_BROWSER_MAX_TITLE_LENGTH = 1024;\n var bbDesktopBrowserViewBoundsSchema = external_exports.object({\n x: external_exports.number().int(),\n y: external_exports.number().int(),\n width: external_exports.number().int().nonnegative(),\n height: external_exports.number().int().nonnegative()\n }).strict();\n var bbDesktopBrowserAttachRequestSchema = external_exports.object({\n tabId: external_exports.string().min(1),\n url: external_exports.string().max(BB_DESKTOP_BROWSER_MAX_URL_LENGTH),\n bounds: bbDesktopBrowserViewBoundsSchema,\n visible: external_exports.boolean()\n }).strict();\n var bbDesktopBrowserNavigateRequestSchema = external_exports.object({\n tabId: external_exports.string().min(1),\n url: external_exports.string().min(1).max(BB_DESKTOP_BROWSER_MAX_URL_LENGTH)\n }).strict();\n var bbDesktopBrowserSetBoundsRequestSchema = external_exports.object({\n tabId: external_exports.string().min(1),\n bounds: bbDesktopBrowserViewBoundsSchema\n }).strict();\n var bbDesktopBrowserSetVisibleRequestSchema = external_exports.object({\n tabId: external_exports.string().min(1),\n visible: external_exports.boolean()\n }).strict();\n var bbDesktopBrowserTabRefSchema = external_exports.object({\n tabId: external_exports.string().min(1)\n }).strict();\n var bbDesktopBrowserStateSchema = external_exports.object({\n tabId: external_exports.string().min(1),\n url: external_exports.string().max(BB_DESKTOP_BROWSER_MAX_URL_LENGTH),\n title: external_exports.string().max(BB_DESKTOP_BROWSER_MAX_TITLE_LENGTH).nullable(),\n isLoading: external_exports.boolean(),\n canGoBack: external_exports.boolean(),\n canGoForward: external_exports.boolean(),\n errorText: external_exports.string().max(BB_DESKTOP_BROWSER_MAX_TITLE_LENGTH).nullable()\n }).strict();\n var bbDesktopBrowserOpenTabRequestSchema = external_exports.object({\n url: external_exports.string().min(1).max(BB_DESKTOP_BROWSER_MAX_URL_LENGTH)\n }).strict();\n var unmanagedBranchSpecSchema = external_exports.discriminatedUnion(\"kind\", [\n external_exports.object({\n kind: external_exports.literal(\"existing\"),\n name: gitBranchNameSchema\n }).strict(),\n external_exports.object({ kind: external_exports.literal(\"new\"), baseBranch: gitBranchNameSchema }).strict()\n ]);\n var unmanagedWorkspaceSchema = external_exports.object({\n type: external_exports.literal(\"unmanaged\"),\n path: external_exports.string().min(1).nullable(),\n /**\n * If set, the daemon checks out this branch in the unmanaged workspace\n * before the thread starts. `existing` switches to a named branch; `new`\n * asks the server to mint a thread-scoped branch name and create it from\n * the requested base branch.\n */\n branch: unmanagedBranchSpecSchema.optional()\n });\n var baseBranchSpecSchema = external_exports.discriminatedUnion(\"kind\", [\n external_exports.object({ kind: external_exports.literal(\"named\"), name: gitBranchNameSchema }),\n external_exports.object({ kind: external_exports.literal(\"default\") })\n ]);\n var managedWorktreeWorkspaceSchema = external_exports.object({\n type: external_exports.literal(\"managed-worktree\"),\n /** Branch the new worktree should be based on. */\n baseBranch: baseBranchSpecSchema\n });\n var personalWorkspaceSchema = external_exports.object({\n type: external_exports.literal(\"personal\")\n });\n var workspaceArgsSchema = external_exports.discriminatedUnion(\"type\", [\n unmanagedWorkspaceSchema,\n managedWorktreeWorkspaceSchema,\n personalWorkspaceSchema\n ]);\n var reuseEnvironmentSchema = external_exports.object({\n type: external_exports.literal(\"reuse\"),\n environmentId: external_exports.string().min(1)\n });\n var hostEnvironmentSchema = external_exports.object({\n type: external_exports.literal(\"host\"),\n hostId: external_exports.string().min(1).optional(),\n workspace: workspaceArgsSchema\n }).superRefine((value, ctx) => {\n if (value.workspace.type !== \"personal\" && value.hostId === void 0) {\n ctx.addIssue({\n code: \"custom\",\n message: \"hostId is required unless workspace.type is personal\",\n path: [\"hostId\"]\n });\n }\n });\n var environmentArgsSchema = external_exports.discriminatedUnion(\"type\", [\n reuseEnvironmentSchema,\n hostEnvironmentSchema\n ]);\n var threadCreateOriginSchema = external_exports.enum([\"app\", \"cli\"]);\n var executionInputFieldSourceSchema = callerExecutionInputSourceSchema;\n var createExecutionInputSourcesSchema = external_exports.object({\n providerId: executionInputFieldSourceSchema.optional(),\n model: executionInputFieldSourceSchema.optional(),\n serviceTier: executionInputFieldSourceSchema.optional(),\n reasoningLevel: executionInputFieldSourceSchema.optional(),\n permissionMode: executionInputFieldSourceSchema.optional()\n }).strict();\n var createManagerExecutionInputSourcesSchema = external_exports.object({\n providerId: executionInputFieldSourceSchema.optional(),\n model: executionInputFieldSourceSchema.optional(),\n serviceTier: executionInputFieldSourceSchema.optional(),\n reasoningLevel: executionInputFieldSourceSchema.optional()\n }).strict();\n var existingThreadExecutionInputSourcesSchema = external_exports.object({\n model: executionInputFieldSourceSchema.optional(),\n serviceTier: executionInputFieldSourceSchema.optional(),\n reasoningLevel: executionInputFieldSourceSchema.optional(),\n permissionMode: executionInputFieldSourceSchema.optional()\n }).strict();\n var createThreadRequestSchema = external_exports.object({\n projectId: external_exports.string().min(1),\n providerId: external_exports.string().min(1).optional(),\n origin: threadCreateOriginSchema,\n title: external_exports.string().min(1).optional(),\n input: external_exports.array(promptInputSchema).min(1),\n model: external_exports.string().min(1).optional(),\n serviceTier: serviceTierSchema.optional(),\n reasoningLevel: reasoningLevelSchema.optional(),\n permissionMode: permissionModeSchema.optional(),\n executionInputSources: createExecutionInputSourcesSchema.optional(),\n environment: environmentArgsSchema,\n parentThreadId: external_exports.string().min(1).optional()\n });\n var automationThreadRequestSchema = external_exports.object({\n // Automations must choose provider/model explicitly; omitted execution\n // options may still inherit scheduled-thread defaults.\n providerId: external_exports.string().min(1),\n title: external_exports.string().min(1).optional(),\n input: external_exports.array(promptInputSchema).min(1),\n model: external_exports.string().min(1),\n serviceTier: serviceTierSchema.optional(),\n reasoningLevel: reasoningLevelSchema.optional(),\n permissionMode: permissionModeSchema.optional(),\n environment: environmentArgsSchema,\n parentThreadId: external_exports.string().min(1).optional()\n });\n var automationNameSchema = external_exports.string().min(1).max(AUTOMATION_NAME_MAX_LENGTH);\n var scheduleCronSchema = external_exports.string().min(1).max(SCHEDULE_CRON_MAX_LENGTH);\n var scheduleNameSchema = external_exports.string().min(1).max(SCHEDULE_NAME_MAX_LENGTH);\n var scheduleTimezoneSchema = external_exports.string().min(1).max(SCHEDULE_TIMEZONE_MAX_LENGTH);\n var automationScheduleTriggerSchema = external_exports.object({\n triggerType: external_exports.literal(\"schedule\"),\n cron: scheduleCronSchema,\n timezone: scheduleTimezoneSchema\n });\n var scheduledThreadAutomationActionSchema = external_exports.object({\n actionType: external_exports.literal(\"scheduled-thread\"),\n threadRequest: automationThreadRequestSchema\n });\n var automationTriggerSchema = external_exports.discriminatedUnion(\"triggerType\", [\n automationScheduleTriggerSchema\n ]);\n var automationActionSchema = external_exports.discriminatedUnion(\"actionType\", [\n scheduledThreadAutomationActionSchema\n ]);\n var automationValidationIssueSchema = external_exports.string().min(1);\n var automationValidationSchema = external_exports.object({\n isValid: external_exports.boolean(),\n validationIssues: external_exports.array(automationValidationIssueSchema)\n });\n var automationSchema = external_exports.object({\n id: external_exports.string().min(1),\n projectId: external_exports.string().min(1),\n name: automationNameSchema,\n enabled: external_exports.boolean(),\n trigger: automationTriggerSchema,\n action: automationActionSchema,\n autoArchive: external_exports.boolean(),\n nextRunAt: external_exports.number().nullable(),\n lastRunAt: external_exports.number().nullable(),\n runCount: external_exports.number().int().nonnegative(),\n isValid: external_exports.boolean(),\n validationIssues: external_exports.array(automationValidationIssueSchema),\n createdAt: external_exports.number(),\n updatedAt: external_exports.number()\n });\n var createAutomationRequestSchema = external_exports.object({\n name: automationNameSchema,\n enabled: external_exports.boolean().optional(),\n trigger: automationTriggerSchema,\n action: automationActionSchema,\n autoArchive: external_exports.boolean().optional()\n });\n var updateAutomationEnabledRequestSchema = external_exports.object({\n enabled: external_exports.boolean()\n }).strict();\n var updateAutomationConfigRequestSchema = external_exports.object({\n name: automationNameSchema,\n trigger: automationTriggerSchema,\n action: automationActionSchema,\n autoArchive: external_exports.boolean()\n }).partial().strict().refine(\n (value) => value.name !== void 0 || value.trigger !== void 0 || value.action !== void 0 || value.autoArchive !== void 0,\n \"At least one field must be provided\"\n );\n var updateAutomationRequestSchema = external_exports.union([\n updateAutomationEnabledRequestSchema,\n updateAutomationConfigRequestSchema\n ]);\n var sendMessageRequestSchema = external_exports.object({\n input: external_exports.array(promptInputSchema).min(1),\n model: external_exports.string().optional(),\n serviceTier: serviceTierSchema.optional(),\n reasoningLevel: reasoningLevelSchema.optional(),\n permissionMode: permissionModeSchema.optional(),\n executionInputSources: existingThreadExecutionInputSourcesSchema.optional(),\n mode: sendMessageModeSchema,\n senderThreadId: external_exports.string().min(1).optional()\n });\n var sendQueuedMessageModeSchema = external_exports.enum([\"auto\", \"steer\"]);\n var createQueuedMessageRequestSchema = external_exports.object({\n input: external_exports.array(promptInputSchema).min(1),\n model: external_exports.string().optional(),\n serviceTier: serviceTierSchema.optional(),\n reasoningLevel: reasoningLevelSchema.optional(),\n permissionMode: permissionModeSchema.optional(),\n executionInputSources: existingThreadExecutionInputSourcesSchema.optional()\n });\n var sendQueuedMessageRequestSchema = external_exports.object({\n mode: sendQueuedMessageModeSchema\n });\n var reorderQueuedMessageRequestSchema = external_exports.object({\n previousQueuedMessageId: external_exports.string().min(1).nullable(),\n nextQueuedMessageId: external_exports.string().min(1).nullable()\n });\n var sendQueuedMessageResponseSchema = external_exports.object({\n ok: external_exports.literal(true),\n queuedMessage: threadQueuedMessageSchema\n });\n var threadListResponseSchema = external_exports.array(threadListEntrySchema);\n var threadResponseSchema = threadWithRuntimeSchema;\n var threadIncludeOptionSchema = external_exports.enum([\"environment\", \"host\"]);\n var threadGetQuerySchema = external_exports.object({\n include: external_exports.string().min(1).refine(\n (value) => isCommaSeparatedIncludeQueryValue({\n allowedValues: threadIncludeOptionSchema.options,\n value\n }),\n { message: \"Invalid include\" }\n ).optional()\n });\n var threadWithIncludesResponseSchema = threadResponseSchema.extend({\n environment: environmentSchema.nullable().optional(),\n host: hostSchema.nullable().optional()\n });\n var threadPendingInteractionsResponseSchema = external_exports.array(\n pendingInteractionSchema\n );\n var threadQueuedMessageListResponseSchema = external_exports.array(\n threadQueuedMessageSchema\n );\n var threadAssignedChildSummaryResponseSchema = external_exports.object({\n nonDeletedAssignedChildCount: external_exports.number().int().nonnegative()\n });\n var deleteThreadRequestSchema = external_exports.object({\n managerChildThreadsConfirmed: external_exports.boolean()\n });\n var updateThreadRequestSchema = external_exports.object({\n title: external_exports.string().min(1).nullable(),\n parentThreadId: external_exports.string().min(1).nullable(),\n // Sticky thread-level execution overrides applied on the next turn. `null`\n // clears the override; an omitted field is left unchanged. Settable\n // together or independently.\n model: external_exports.string().min(1).nullable(),\n reasoningLevel: reasoningLevelSchema.nullable()\n }).partial().refine(\n (value) => value.title !== void 0 || value.parentThreadId !== void 0 || value.model !== void 0 || value.reasoningLevel !== void 0,\n \"At least one field must be provided\"\n );\n var updateEnvironmentRequestSchema = external_exports.object({\n mergeBaseBranch: gitBranchNameSchema.nullable()\n });\n var localProjectPathRequestSchema = external_exports.string().trim().min(1).transform(normalizeProjectPathInput).superRefine((path, ctx) => {\n const validationMessage = getProjectPathValidationMessage(path);\n if (!validationMessage) {\n return;\n }\n ctx.addIssue({\n code: external_exports.ZodIssueCode.custom,\n message: validationMessage\n });\n });\n var createLocalPathProjectSourceRequestSchema = external_exports.object({\n hostId: external_exports.string().min(1),\n type: external_exports.literal(\"local_path\"),\n path: localProjectPathRequestSchema\n }).strict();\n var createProjectSourceRequestSchema = createLocalPathProjectSourceRequestSchema;\n var createProjectRequestSchema = external_exports.object({\n name: external_exports.string().min(1),\n source: createProjectSourceRequestSchema\n });\n var reorderProjectRequestSchema = external_exports.object({\n previousProjectId: external_exports.string().min(1).nullable(),\n nextProjectId: external_exports.string().min(1).nullable()\n });\n var reorderManagerThreadRequestSchema = external_exports.object({\n previousThreadId: external_exports.string().min(1).nullable(),\n nextThreadId: external_exports.string().min(1).nullable()\n });\n var reorderPinnedThreadRequestSchema = external_exports.object({\n previousThreadId: external_exports.string().min(1).nullable(),\n nextThreadId: external_exports.string().min(1).nullable()\n });\n var persistentHostJoinRequestSchema = external_exports.object({\n hostId: external_exports.string().min(1).optional(),\n hostType: external_exports.literal(\"persistent\").optional()\n }).strict();\n var localHostJoinRequestSchema = external_exports.object({\n hostId: external_exports.string().min(1).optional(),\n hostType: external_exports.literal(\"persistent\"),\n joinMode: external_exports.literal(\"local\")\n }).strict();\n var createHostJoinRequestSchema = external_exports.union([\n localHostJoinRequestSchema,\n persistentHostJoinRequestSchema\n ]);\n var createHostJoinResponseSchema = external_exports.object({\n expiresAt: external_exports.number().int().positive(),\n hostId: external_exports.string().min(1),\n joinCode: external_exports.string().min(1),\n joinCommand: external_exports.string().min(1)\n });\n var updateHostRequestSchema = external_exports.object({\n name: external_exports.string().min(1)\n }).partial().refine(\n (value) => value.name !== void 0,\n \"At least one field must be provided\"\n );\n var managerHostEnvironmentSchema = external_exports.object({\n type: external_exports.literal(\"host\"),\n hostId: external_exports.string().min(1)\n });\n var managerEnvironmentArgsSchema = external_exports.discriminatedUnion(\"type\", [\n managerHostEnvironmentSchema\n ]);\n var createManagerThreadRequestSchema = external_exports.object({\n name: external_exports.string().min(1).optional(),\n providerId: external_exports.string().min(1).optional(),\n origin: threadCreateOriginSchema,\n model: external_exports.string().min(1).optional(),\n serviceTier: serviceTierSchema.optional(),\n reasoningLevel: reasoningLevelSchema.optional(),\n executionInputSources: createManagerExecutionInputSourcesSchema.optional(),\n environment: managerEnvironmentArgsSchema,\n /**\n * Optional user-provided first message. When present and contains\n * meaningful content (any non-text part, or text with non-whitespace\n * content), replaces the default `systemMessageManagerWelcome` template\n * as the manager's first message. Omit to use the welcome-message\n * fallback \u2014 the schema rejects empty arrays. Whitespace-only text\n * input is also treated as no-input at the route boundary.\n */\n input: external_exports.array(promptInputSchema).min(1).optional()\n }).strict();\n var projectListIncludeOptionSchema = external_exports.enum([\"threads\"]);\n var projectListQuerySchema = external_exports.object({\n include: external_exports.string().min(1).refine(\n (value) => isCommaSeparatedIncludeQueryValue({\n allowedValues: projectListIncludeOptionSchema.options,\n value\n }),\n { message: \"Invalid include\" }\n ).optional()\n });\n var projectFilesQuerySchema = external_exports.object({\n query: external_exports.string().min(1).max(FILE_LIST_QUERY_MAX_LENGTH).optional(),\n limit: external_exports.string().regex(/^\\d+$/).optional(),\n /**\n * Required + nullable. Pass an environment id to scope the file list to that\n * environment's workspace (e.g. a worktree); pass `null` to use the project's\n * default source. Encoded as the empty string on the wire because URL query\n * params can't represent JSON null directly.\n */\n environmentId: external_exports.preprocess(\n (value) => value === \"\" ? null : value,\n external_exports.string().min(1).nullable()\n )\n });\n var pathListIncludeQueryValueSchema = external_exports.enum([\"true\", \"false\"]);\n var projectPathsQuerySchema = projectFilesQuerySchema.extend({\n includeFiles: pathListIncludeQueryValueSchema,\n includeDirectories: pathListIncludeQueryValueSchema\n });\n var branchListQuerySchema = external_exports.object({\n query: external_exports.string().min(1).max(BRANCH_LIST_QUERY_MAX_LENGTH).optional(),\n limit: external_exports.string().regex(/^\\d+$/).optional()\n });\n var environmentDiffBranchesQuerySchema = branchListQuerySchema.extend({\n selectedBranch: gitBranchNameSchema.optional()\n });\n var projectBranchesQuerySchema = branchListQuerySchema.extend({\n hostId: external_exports.string().min(1),\n selectedBranch: gitBranchNameSchema.optional()\n });\n var environmentDiffBranchesResponseSchema = external_exports.object({\n /** Local branches under refs/heads, safe for checkout and write targets. */\n branches: external_exports.array(external_exports.string()),\n branchesTruncated: external_exports.boolean(),\n /** Remote-tracking branches under refs/remotes, for base/diff selection. */\n remoteBranches: external_exports.array(external_exports.string()),\n remoteBranchesTruncated: external_exports.boolean(),\n selectedBranch: gitBranchRefClassificationSchema.nullable()\n });\n var projectAttachmentContentQuerySchema = external_exports.object({\n path: external_exports.string().min(1)\n });\n var projectDefaultExecutionOptionsQuerySchema = external_exports.object({\n threadType: threadTypeSchema\n });\n var promptHistoryQuerySchema = external_exports.object({\n limit: external_exports.string().regex(/^\\d+$/)\n }).partial();\n var promptHistoryResponseSchema = external_exports.array(promptHistoryEntrySchema);\n var systemExecutionOptionsModelLoadErrorCodeSchema = external_exports.enum([\n \"missing_executable\",\n \"timeout\",\n \"failed\"\n ]);\n var systemExecutionOptionsModelLoadErrorSchema = external_exports.object({\n providerId: external_exports.string().min(1),\n code: systemExecutionOptionsModelLoadErrorCodeSchema\n });\n var systemExecutionOptionsResponseSchema = external_exports.object({\n providers: external_exports.array(providerInfoSchema),\n /** Active models offered as fresh picker choices. */\n models: external_exports.array(availableModelSchema),\n /**\n * Retired/legacy models the picker no longer offers but that may still be\n * the user's stored selection. Clients prepend the matching entry when a\n * stored model isn't in `models`, so deprecation doesn't silently rewrite\n * the user's choice.\n */\n selectedOnlyModels: external_exports.array(availableModelSchema),\n /**\n * Error for the provider whose model list was requested. Null means the\n * lookup completed or no provider was available to query.\n */\n modelLoadError: systemExecutionOptionsModelLoadErrorSchema.nullable()\n });\n var threadComposerBootstrapResponseSchema = external_exports.object({\n defaultExecutionOptions: resolvedThreadExecutionOptionsSchema.nullable(),\n queuedMessages: threadQueuedMessageListResponseSchema,\n /**\n * Provider/model options for the thread's composer picker. Null when the\n * server deliberately skips resolving them \u2014 for archived or environment-less\n * threads, whose follow-up composer locks the provider and needs no list.\n * Null means \"not resolved\", distinct from a resolved-but-empty list, so\n * callers must not treat it as a system-wide answer (e.g. don't seed the\n * shared system-execution-options cache with it).\n */\n executionOptions: systemExecutionOptionsResponseSchema.nullable(),\n pendingInteractions: threadPendingInteractionsResponseSchema,\n promptHistory: promptHistoryResponseSchema\n });\n var mergeBaseBranchQuerySchema = external_exports.string(\"A merge base branch is required\").pipe(gitBranchNameSchema);\n var environmentStatusQuerySchema = external_exports.object({\n mergeBaseBranch: mergeBaseBranchQuerySchema.optional()\n });\n var environmentDiffQuerySchema = external_exports.discriminatedUnion(\"target\", [\n external_exports.object({\n target: external_exports.literal(\"uncommitted\")\n }),\n external_exports.object({\n target: external_exports.literal(\"branch_committed\"),\n mergeBaseBranch: mergeBaseBranchQuerySchema\n }),\n external_exports.object({\n target: external_exports.literal(\"all\"),\n mergeBaseBranch: mergeBaseBranchQuerySchema\n }),\n external_exports.object({\n target: external_exports.literal(\"commit\"),\n sha: external_exports.string().regex(/^[0-9a-f]{4,40}$/iu)\n })\n ]);\n var diffFileSideSchema = external_exports.enum([\"old\", \"new\"]);\n var mergeBaseRefQuerySchema = external_exports.string().regex(/^[0-9a-f]{4,40}$/iu);\n var environmentDiffFileQuerySchema = external_exports.discriminatedUnion(\"target\", [\n external_exports.object({\n target: external_exports.literal(\"uncommitted\"),\n path: external_exports.string().min(1),\n side: diffFileSideSchema\n }),\n external_exports.object({\n target: external_exports.literal(\"branch_committed\"),\n mergeBaseRef: mergeBaseRefQuerySchema,\n path: external_exports.string().min(1),\n side: diffFileSideSchema\n }),\n external_exports.object({\n target: external_exports.literal(\"all\"),\n mergeBaseRef: mergeBaseRefQuerySchema,\n path: external_exports.string().min(1),\n side: diffFileSideSchema\n }),\n external_exports.object({\n target: external_exports.literal(\"commit\"),\n sha: external_exports.string().regex(/^[0-9a-f]{4,40}$/iu),\n path: external_exports.string().min(1),\n side: diffFileSideSchema\n })\n ]);\n var environmentDiffFileResponseSchema = external_exports.object({\n path: external_exports.string(),\n content: external_exports.string(),\n contentEncoding: external_exports.enum([\"base64\", \"utf8\"]),\n mimeType: external_exports.string().optional(),\n sizeBytes: external_exports.number().int().nonnegative()\n });\n var environmentArchiveThreadsResponseSchema = external_exports.object({\n ok: external_exports.literal(true),\n archivedThreadIds: external_exports.array(external_exports.string().min(1))\n });\n var managerArchiveThreadsResponseSchema = external_exports.object({\n ok: external_exports.literal(true),\n archivedThreadIds: external_exports.array(external_exports.string().min(1))\n });\n var threadListQuerySchema = external_exports.object({\n projectId: external_exports.string().min(1).optional(),\n type: threadTypeSchema.optional(),\n parentThreadId: external_exports.string().min(1).optional(),\n archived: external_exports.enum([\"true\", \"false\"]).optional(),\n /** Filter by parent thread presence: \"true\" \u2192 managed (has parent), \"false\" \u2192 unmanaged. */\n managed: external_exports.enum([\"true\", \"false\"]).optional(),\n limit: external_exports.string().regex(/^\\d+$/).optional(),\n offset: external_exports.string().regex(/^\\d+$/).optional()\n });\n var managerTimelineViewSchema = external_exports.enum([\"conversation\", \"standard\"]);\n var timelinePaginationCursorSchema = external_exports.object({\n anchorSeq: external_exports.number().int().positive(),\n anchorId: external_exports.string().min(1)\n }).strict();\n var timelinePageMetadataSchema = external_exports.object({\n kind: external_exports.enum([\"latest\", \"older\"]),\n segmentLimit: external_exports.number().int().positive(),\n returnedSegmentCount: external_exports.number().int().nonnegative(),\n hasOlderRows: external_exports.boolean(),\n olderCursor: timelinePaginationCursorSchema.nullable()\n }).strict();\n var threadTimelineQuerySchema = external_exports.object({\n managerTimelineView: managerTimelineViewSchema,\n includeNestedRows: external_exports.enum([\"true\", \"false\"]),\n segmentLimit: external_exports.string().regex(/^\\d+$/),\n beforeAnchorSeq: external_exports.string().regex(/^[1-9]\\d*$/),\n beforeAnchorId: external_exports.string().min(1),\n /**\n * When `\"true\"`, the response omits row generation and returns\n * `rows: []` with the tail-only fields (`activeThinking`, `pendingTodos`,\n * `contextWindowUsage`) populated normally. Used by the CLI to read\n * tail state without paying for the full row payload on every\n * `bb status` invocation. Implies `latest` page semantics.\n */\n summaryOnly: external_exports.enum([\"true\", \"false\"])\n }).partial().superRefine((query, context) => {\n const hasBeforeAnchorSeq = query.beforeAnchorSeq !== void 0;\n const hasBeforeAnchorId = query.beforeAnchorId !== void 0;\n if (hasBeforeAnchorSeq === hasBeforeAnchorId) {\n return;\n }\n context.addIssue({\n code: \"custom\",\n message: \"beforeAnchorSeq and beforeAnchorId must be provided together\",\n path: hasBeforeAnchorSeq ? [\"beforeAnchorId\"] : [\"beforeAnchorSeq\"]\n });\n });\n var timelineTurnSummaryDetailsQuerySchema = external_exports.object({\n turnId: external_exports.string().min(1),\n sourceSeqStart: external_exports.string().regex(/^\\d+$/),\n sourceSeqEnd: external_exports.string().regex(/^\\d+$/),\n managerTimelineView: managerTimelineViewSchema.optional()\n });\n var threadEventsQuerySchema = external_exports.object({\n afterSeq: external_exports.string().regex(/^\\d+$/),\n limit: external_exports.string().regex(/^\\d+$/)\n }).partial();\n var threadEventWaitQuerySchema = external_exports.object({\n type: external_exports.string().min(1),\n afterSeq: external_exports.string().regex(/^\\d+$/).optional(),\n waitMs: external_exports.string().regex(/^\\d+$/).optional()\n });\n var threadStorageFilesQuerySchema = external_exports.object({\n query: external_exports.string().min(1).max(FILE_LIST_QUERY_MAX_LENGTH),\n limit: external_exports.string().regex(/^\\d+$/)\n }).partial();\n var threadStoragePathsQuerySchema = threadStorageFilesQuerySchema.extend({\n includeFiles: pathListIncludeQueryValueSchema,\n includeDirectories: pathListIncludeQueryValueSchema\n });\n var threadStorageContentQuerySchema = external_exports.object({\n path: external_exports.string().min(1)\n });\n var threadHostFileContentQuerySchema = external_exports.object({\n path: external_exports.string().min(1)\n });\n var appEntryPathSegmentPattern = /^[A-Za-z0-9._-]{1,120}$/u;\n function isValidAppEntryPath(value) {\n if (value.length === 0 || value.length > 512 || value.includes(\"\\0\") || value.includes(\"\\\\\") || value.startsWith(\"/\") || value.endsWith(\"/\")) {\n return false;\n }\n const segments = value.split(\"/\");\n return segments.every(\n (segment) => segment !== \".\" && segment !== \"..\" && !segment.startsWith(\".\") && appEntryPathSegmentPattern.test(segment)\n );\n }\n var appIconNameValues = [\n \"AlertCircle\",\n \"AlertTriangle\",\n \"AlignLeft\",\n \"Archive\",\n \"ArchiveRestore\",\n \"ArrowDown\",\n \"ArrowRight\",\n \"ArrowUp\",\n \"AudioLines\",\n \"Check\",\n \"ChevronDown\",\n \"ChevronLeft\",\n \"ChevronRight\",\n \"ChevronUp\",\n \"ChevronsDown\",\n \"ChevronsUp\",\n \"Circle\",\n \"CircleCheck\",\n \"CircleDashed\",\n \"CircleX\",\n \"Columns2\",\n \"Container\",\n \"Copy\",\n \"CornerDownLeft\",\n \"CornerDownRight\",\n \"Edit\",\n \"ExternalLink\",\n \"FileDiff\",\n \"File\",\n \"FileQuestion\",\n \"FileX2\",\n \"Folder\",\n \"FolderOpen\",\n \"FolderMinus\",\n \"FolderPlus\",\n \"GitBranch\",\n \"GitMerge\",\n \"GridView\",\n \"Info\",\n \"Laptop\",\n \"ListTodo\",\n \"Maximize2\",\n \"MessageSquarePlus\",\n \"MessageSquare\",\n \"Mic\",\n \"Minimize2\",\n \"MoreHorizontal\",\n \"PanelBottom\",\n \"PanelLeft\",\n \"PanelRight\",\n \"Paperclip\",\n \"Plus\",\n \"RotateCcw\",\n \"Rows2\",\n \"Search\",\n \"Settings\",\n \"Spinner\",\n \"Square\",\n \"Terminal\",\n \"Trash2\",\n \"UserRound\",\n \"UserRoundPlus\",\n \"X\",\n \"Zap\"\n ];\n var appIconNameSchema = external_exports.enum(appIconNameValues);\n var appEntryKindSchema = external_exports.enum([\"html\", \"md\"]);\n var appEntryPathSchema = external_exports.string().refine(isValidAppEntryPath, \"Invalid app entry path\");\n var appEntrySchema = external_exports.object({\n path: appEntryPathSchema,\n kind: appEntryKindSchema\n }).strict();\n var appCapabilitySchema = external_exports.enum([\"data\", \"message\"]);\n var appDisplayNameSchema = external_exports.string().max(80);\n var appManifestSchema = external_exports.object({\n manifestVersion: external_exports.literal(1).default(1),\n id: applicationIdSchema,\n name: appDisplayNameSchema.optional(),\n icon: appIconNameSchema.optional(),\n entry: appEntryPathSchema.optional(),\n /** Inert reserved metadata \u2014 see {@link appCapabilitySchema}. */\n capabilities: external_exports.array(appCapabilitySchema).default([])\n }).strict().transform((manifest) => ({\n ...manifest,\n name: manifest.name === void 0 || manifest.name.trim().length === 0 ? manifest.id : manifest.name\n }));\n var appIconSchema = external_exports.discriminatedUnion(\"kind\", [\n external_exports.object({\n kind: external_exports.literal(\"builtin\"),\n name: appIconNameSchema\n }).strict(),\n external_exports.object({\n kind: external_exports.literal(\"logo\"),\n url: external_exports.string().min(1)\n }).strict()\n ]);\n var appSummarySchema = external_exports.object({\n applicationId: applicationIdSchema,\n name: external_exports.string().min(1).max(80),\n entry: appEntrySchema,\n capabilities: external_exports.array(appCapabilitySchema),\n icon: appIconSchema\n }).strict();\n var appDetailSchema = appSummarySchema.extend({\n appsRootPath: external_exports.string().min(1),\n appRootPath: external_exports.string().min(1),\n appDataPath: external_exports.string().min(1)\n }).strict();\n var createAppRequestSchema = external_exports.object({\n applicationId: applicationIdSchema.optional(),\n name: appDisplayNameSchema.optional()\n }).strict().superRefine((request, context) => {\n const hasName = request.name !== void 0 && request.name.trim().length > 0;\n if (request.applicationId === void 0 && !hasName) {\n context.addIssue({\n code: \"custom\",\n message: \"Provide applicationId or name\"\n });\n }\n });\n var appDataEntrySchema = external_exports.object({\n path: appDataPathSchema,\n value: jsonValueSchema,\n version: external_exports.string().min(1),\n sizeBytes: external_exports.number().int().nonnegative(),\n modifiedAtMs: external_exports.number().nonnegative()\n }).strict();\n var appDataReadResponseSchema = appDataEntrySchema;\n var appDataListQuerySchema = external_exports.object({\n prefix: appDataPathSchema.or(external_exports.literal(\"\"))\n }).partial();\n var appDataListResponseSchema = external_exports.object({\n entries: external_exports.array(appDataEntrySchema)\n }).strict();\n var appDataWriteRequestSchema = external_exports.object({\n value: jsonValueSchema\n }).strict();\n var appMessageRequestSchema = external_exports.object({\n payload: jsonValueSchema,\n appSessionToken: external_exports.string().regex(/^appsess_[A-Za-z0-9_-]+$/u).optional(),\n targetThreadId: external_exports.string().min(1).optional()\n }).strict();\n var appDataChangedBroadcastMessageSchema = external_exports.object({\n type: external_exports.literal(\"app-data.changed\"),\n applicationId: applicationIdSchema,\n path: appDataPathSchema,\n value: jsonValueSchema.nullable(),\n deleted: external_exports.boolean(),\n version: external_exports.string().min(1).nullable()\n }).strict();\n var appDataResyncBroadcastMessageSchema = external_exports.object({\n type: external_exports.literal(\"app-data.resync\"),\n applicationId: applicationIdSchema\n }).strict();\n var appDataBroadcastMessageSchema = external_exports.discriminatedUnion(\"type\", [\n appDataChangedBroadcastMessageSchema,\n appDataResyncBroadcastMessageSchema\n ]);\n var serverMessageSchema = external_exports.union([\n changedMessageSchema,\n appDataBroadcastMessageSchema\n ]);\n var appDataChangedBroadcastMessageLenientSchema = external_exports.object({\n type: external_exports.literal(\"app-data.changed\"),\n applicationId: applicationIdSchema,\n path: appDataPathSchema,\n value: jsonValueSchema.nullable(),\n deleted: external_exports.boolean(),\n version: external_exports.string().min(1).nullable()\n });\n var appDataResyncBroadcastMessageLenientSchema = external_exports.object({\n type: external_exports.literal(\"app-data.resync\"),\n applicationId: applicationIdSchema\n });\n var serverMessageLenientSchema = external_exports.union([\n changedMessageLenientSchema,\n appDataChangedBroadcastMessageLenientSchema,\n appDataResyncBroadcastMessageLenientSchema\n ]);\n var systemExecutionOptionsQuerySchema = external_exports.object({\n providerId: external_exports.string().min(1),\n hostId: external_exports.string().min(1),\n environmentId: external_exports.string().min(1)\n }).partial();\n var systemProvidersQuerySchema = external_exports.object({\n hostId: external_exports.string().min(1),\n environmentId: external_exports.string().min(1)\n }).partial();\n var updateProjectRequestSchema = external_exports.object({\n name: external_exports.string().min(1)\n }).partial().refine(\n (value) => value.name !== void 0,\n \"At least one field must be provided\"\n );\n var updateProjectSourceRequestSchema = external_exports.object({\n type: external_exports.literal(\"local_path\"),\n path: localProjectPathRequestSchema.optional(),\n isDefault: external_exports.literal(true).optional()\n }).strict().refine(\n (value) => value.path !== void 0 || value.isDefault !== void 0,\n \"At least one field besides type must be provided\"\n );\n var environmentActionTypeSchema = external_exports.enum([\"commit\", \"squash_merge\"]);\n var squashMergeOptionsSchema = external_exports.object({\n mergeBaseBranch: gitBranchNameSchema\n }).strict();\n var environmentActionRequestSchema = external_exports.discriminatedUnion(\"action\", [\n external_exports.object({\n action: external_exports.literal(\"commit\")\n }).strict(),\n external_exports.object({\n action: external_exports.literal(\"squash_merge\"),\n options: squashMergeOptionsSchema\n }).strict()\n ]);\n var commitActionResponseSchema = external_exports.object({\n ok: external_exports.literal(true),\n action: external_exports.literal(\"commit\"),\n message: external_exports.string().min(1),\n commitSha: external_exports.string().min(1),\n commitSubject: external_exports.string().min(1)\n });\n var squashMergeActionResponseSchema = external_exports.object({\n ok: external_exports.literal(true),\n action: external_exports.literal(\"squash_merge\"),\n merged: external_exports.boolean(),\n message: external_exports.string().min(1),\n commitSha: external_exports.string().min(1),\n commitSubject: external_exports.string().min(1)\n });\n var environmentActionResponseSchema = external_exports.discriminatedUnion(\"action\", [\n commitActionResponseSchema,\n squashMergeActionResponseSchema\n ]);\n var environmentActionFailureDetailsSchema = external_exports.discriminatedUnion(\n \"kind\",\n [\n external_exports.object({\n kind: external_exports.literal(\"commit_failed\"),\n errorMessage: external_exports.string()\n }),\n external_exports.object({\n kind: external_exports.literal(\"squash_merge_conflict\"),\n conflictFiles: external_exports.array(external_exports.string())\n }),\n external_exports.object({\n kind: external_exports.literal(\"squash_merge_commit_failed\"),\n stage: external_exports.enum([\"prep_commit\", \"squash_commit\"]),\n errorMessage: external_exports.string()\n }),\n external_exports.object({\n kind: external_exports.literal(\"workspace_unavailable\"),\n failure: workspaceResolutionFailureSchema\n })\n ]\n );\n var environmentActionApiErrorSchema = apiErrorSchema.extend({\n details: environmentActionFailureDetailsSchema.optional()\n });\n var terminalSessionSchema = external_exports.object({\n id: external_exports.string().min(1),\n threadId: external_exports.string().min(1),\n environmentId: external_exports.string().min(1),\n hostId: external_exports.string().min(1),\n title: external_exports.string().min(1),\n initialCwd: external_exports.string().min(1),\n currentCwd: external_exports.string().min(1).nullable(),\n cols: terminalColsSchema,\n rows: terminalRowsSchema,\n status: terminalSessionStatusSchema,\n exitCode: external_exports.number().int().nullable(),\n closeReason: terminalSessionCloseReasonSchema.nullable(),\n createdAt: external_exports.number().int().nonnegative(),\n updatedAt: external_exports.number().int().nonnegative(),\n lastUserInputAt: external_exports.number().int().nonnegative().nullable()\n });\n var threadTerminalListResponseSchema = external_exports.object({\n sessions: external_exports.array(terminalSessionSchema)\n });\n var createThreadTerminalRequestSchema = external_exports.object({\n cols: terminalColsSchema,\n rows: terminalRowsSchema\n }).strict();\n var closeThreadTerminalRequestSchema = external_exports.object({\n mode: external_exports.enum([\"force\", \"if-clean\"]),\n reason: external_exports.literal(\"user\")\n }).strict();\n var updateThreadTerminalRequestSchema = external_exports.object({\n title: external_exports.string().trim().min(1).max(200)\n }).strict();\n var terminalOutputChunkSchema = external_exports.object({\n seq: external_exports.number().int().nonnegative(),\n dataBase64: terminalDataBase64Schema\n }).strict();\n var terminalClientMessageSchema = external_exports.discriminatedUnion(\"type\", [\n external_exports.object({\n type: external_exports.literal(\"input\"),\n dataBase64: terminalDataBase64Schema\n }).strict(),\n external_exports.object({\n type: external_exports.literal(\"resize\"),\n cols: terminalColsSchema,\n rows: terminalRowsSchema\n }).strict(),\n external_exports.object({\n type: external_exports.literal(\"close\"),\n reason: external_exports.literal(\"user\")\n }).strict(),\n external_exports.object({\n type: external_exports.literal(\"ping\")\n }).strict()\n ]);\n var terminalServerMessageSchema = external_exports.discriminatedUnion(\"type\", [\n external_exports.object({\n type: external_exports.literal(\"attached\"),\n session: terminalSessionSchema,\n nextSeq: external_exports.number().int().nonnegative()\n }).strict(),\n external_exports.object({\n type: external_exports.literal(\"output\"),\n chunk: terminalOutputChunkSchema\n }).strict(),\n external_exports.object({\n type: external_exports.literal(\"session-updated\"),\n session: terminalSessionSchema\n }).strict(),\n external_exports.object({\n type: external_exports.literal(\"exited\"),\n session: terminalSessionSchema\n }).strict(),\n external_exports.object({\n type: external_exports.literal(\"error\"),\n code: external_exports.string().min(1),\n message: external_exports.string().min(1)\n }).strict(),\n external_exports.object({\n type: external_exports.literal(\"pong\")\n }).strict()\n ]);\n var timelineTurnSummaryDetailsRequestSchema = external_exports.object({\n turnId: external_exports.string().min(1),\n sourceSeqStart: external_exports.number().int().nonnegative(),\n sourceSeqEnd: external_exports.number().int().nonnegative(),\n managerTimelineView: managerTimelineViewSchema.optional()\n });\n var timelineTurnSummaryDetailsResponseSchema = external_exports.object({\n rows: external_exports.array(timelineRowSchema)\n });\n var threadTimelineResponseSchema = external_exports.object({\n rows: external_exports.array(timelineRowSchema),\n activeThinking: activeThinkingSchema.nullable(),\n pendingTodos: threadTimelinePendingTodosSchema.nullable(),\n contextWindowUsage: threadContextWindowUsageSchema.optional(),\n timelinePage: timelinePageMetadataSchema\n });\n var systemVoiceTranscriptionResponseSchema = external_exports.object({\n text: external_exports.string()\n });\n var workspaceFileSchema = external_exports.object({\n path: external_exports.string(),\n name: external_exports.string()\n });\n var workspacePathEntryKindSchema = external_exports.enum([\"file\", \"directory\"]);\n var workspacePathEntrySchema = external_exports.object({\n kind: workspacePathEntryKindSchema,\n path: external_exports.string(),\n name: external_exports.string(),\n score: external_exports.number(),\n positions: external_exports.array(external_exports.number().int().nonnegative())\n });\n var workspaceFileListResponseSchema = external_exports.object({\n files: external_exports.array(workspaceFileSchema),\n truncated: external_exports.boolean()\n });\n var workspacePathListResponseSchema = external_exports.object({\n paths: external_exports.array(workspacePathEntrySchema),\n truncated: external_exports.boolean()\n });\n var threadStorageFileListResponseSchema = workspaceFileListResponseSchema.extend({\n /**\n * Absolute on-host path to the thread's storage directory. Useful for\n * clients that need to construct a full path for filesystem operations\n * (e.g. opening a storage file in the user's editor). The path is on\n * the thread's host machine, so it is only usable when that host is the\n * user's local machine.\n */\n storageRootPath: external_exports.string()\n });\n var threadStoragePathListResponseSchema = workspacePathListResponseSchema.extend({\n /**\n * Absolute on-host path to the thread's storage directory. Useful for\n * clients that need to construct a full path for filesystem operations\n * (e.g. opening a storage file in the user's editor). The path is on\n * the thread's host machine, so it is only usable when that host is the\n * user's local machine.\n */\n storageRootPath: external_exports.string()\n });\n var projectResponseSchema = projectSchema.extend({\n sources: external_exports.array(projectSourceSchema)\n });\n var projectWithThreadsResponseSchema = projectResponseSchema.extend({\n threads: external_exports.array(threadListEntrySchema)\n });\n var sidebarBootstrapResponseSchema = external_exports.object({\n projects: external_exports.array(projectWithThreadsResponseSchema),\n personalProject: projectWithThreadsResponseSchema\n });\n var systemConfigResponseSchema = external_exports.object({\n featureFlags: featureFlagsSchema,\n hostDaemonPort: external_exports.number().nullable(),\n voiceTranscriptionEnabled: external_exports.boolean()\n });\n var systemVersionResponseSchema = external_exports.object({\n /** Version of the running bb-app package, read from package.json. */\n currentVersion: external_exports.string(),\n /** Latest version published to npm, or null when the lookup is unavailable. */\n latestVersion: external_exports.string().nullable(),\n /** Identifier for where the latest version was fetched from. */\n source: external_exports.literal(\"npm\"),\n /** True only when prod-mode, both versions parse, and latest > current. */\n updateAvailable: external_exports.boolean(),\n /** Mirrors deps.config.isDevelopment so the frontend can skip the toast. */\n isDevelopment: external_exports.boolean(),\n /** Command users should run to upgrade. Server-owned product policy. */\n upgradeCommand: external_exports.string()\n });\n var systemConfigReloadResponseSchema = external_exports.object({\n ok: external_exports.literal(true)\n });\n var environmentWorkspaceNotApplicableReasonSchema = external_exports.enum([\n \"non_git_environment\"\n ]);\n var environmentWorkspaceNotApplicableOutcomeSchema = external_exports.object({\n outcome: external_exports.literal(\"not_applicable\"),\n reason: environmentWorkspaceNotApplicableReasonSchema,\n message: external_exports.string().min(1)\n }).strict();\n var environmentStatusResponseSchema = external_exports.discriminatedUnion(\"outcome\", [\n external_exports.object({\n outcome: external_exports.literal(\"available\"),\n workspace: workspaceStatusSchema\n }).strict(),\n environmentWorkspaceNotApplicableOutcomeSchema,\n external_exports.object({\n outcome: external_exports.literal(\"unavailable\"),\n failure: workspaceResolutionFailureSchema\n }).strict()\n ]);\n var environmentDiffResponseSchema = external_exports.discriminatedUnion(\"outcome\", [\n external_exports.object({\n outcome: external_exports.literal(\"available\"),\n diff: threadGitDiffResponseSchema\n }).strict(),\n environmentWorkspaceNotApplicableOutcomeSchema,\n external_exports.object({\n outcome: external_exports.literal(\"unavailable\"),\n failure: workspaceResolutionFailureSchema\n }).strict()\n ]);\n var uploadedPromptAttachmentSchema = external_exports.object({\n type: external_exports.enum([\"localImage\", \"localFile\"]),\n path: external_exports.string(),\n name: external_exports.string(),\n mimeType: external_exports.string().optional(),\n sizeBytes: external_exports.number()\n });\n\n // ../server-contract/src/public-api.ts\n function createPublicApiClient(baseUrl, options) {\n return hc(`${baseUrl}/api/v1`, options);\n }\n function createApiClient(baseUrl, options) {\n const apiClient = createPublicApiClient(baseUrl, options);\n return {\n api: {\n v1: apiClient\n }\n };\n }\n\n // ../core-ui/src/unknown-helpers.ts\n function isRecord(value) {\n return value !== null && typeof value === \"object\" && !Array.isArray(value);\n }\n function toRecord(value) {\n return isRecord(value) ? value : null;\n }\n function extractErrorMessage(value, opts) {\n if (typeof value === \"string\") {\n const normalized = value.replace(/\\s+/g, \" \").trim();\n if (normalized.length === 0) return null;\n if (opts?.maxLength && normalized.length > opts.maxLength) {\n return `${normalized.slice(0, opts.maxLength - 1)}...`;\n }\n return normalized;\n }\n if (Array.isArray(value)) {\n for (const item of value) {\n const message = extractErrorMessage(item, opts);\n if (message) return message;\n }\n return null;\n }\n const record2 = toRecord(value);\n if (!record2) return null;\n if (typeof record2.message === \"string\") {\n const message = extractErrorMessage(record2.message, opts);\n if (message) return message;\n }\n for (const key of opts?.legacyKeys ?? [\"detail\"]) {\n const message = extractErrorMessage(record2[key], opts);\n if (message) return message;\n }\n return null;\n }\n\n // src/response.ts\n var ERROR_EXTRACT_OPTS = {\n legacyKeys: [\"detail\"]\n };\n function formatRequestTimeoutDuration(timeoutMs) {\n const seconds = timeoutMs / 1e3;\n if (!Number.isInteger(seconds)) {\n return `${timeoutMs} ms`;\n }\n return seconds === 1 ? \"1 second\" : `${seconds} seconds`;\n }\n var BbRequestTimeoutError = class extends Error {\n constructor(timeoutMs) {\n super(\n `BB request timed out after ${formatRequestTimeoutDuration(timeoutMs)}.`\n );\n this.name = \"BbRequestTimeoutError\";\n }\n };\n var BbHttpError = class extends Error {\n code;\n status;\n constructor(args) {\n super(`HTTP ${args.status}: ${args.message}`);\n this.name = \"BbHttpError\";\n this.code = args.code;\n this.status = args.status;\n }\n };\n async function readJsonResponse(args) {\n const response = await resolveResponse({ response: args.response });\n return response.json();\n }\n async function readVoidResponse(args) {\n await resolveResponse({ response: args.response });\n }\n async function resolveResponse(args) {\n let response;\n try {\n response = await args.response;\n } catch (error48) {\n if (isTypeErrorWithCauseCode(error48, \"ECONNREFUSED\")) {\n throw new Error(\n \"Cannot connect to BB server. Ensure it is running and BB_SERVER_URL is correct.\"\n );\n }\n throw error48;\n }\n if (!response.ok) {\n const { code, message } = await readHttpErrorInfo(response);\n throw new BbHttpError({ code, message, status: response.status });\n }\n return response;\n }\n function isTypeErrorWithCauseCode(error48, expectedCode) {\n if (!(error48 instanceof TypeError)) {\n return false;\n }\n const { cause } = error48;\n if (!cause || typeof cause !== \"object\") {\n return false;\n }\n return \"code\" in cause && cause.code === expectedCode;\n }\n function readHttpErrorCode(parsed) {\n if (parsed === null || typeof parsed !== \"object\" || Array.isArray(parsed)) {\n return null;\n }\n if (!(\"code\" in parsed)) {\n return null;\n }\n const { code } = parsed;\n return typeof code === \"string\" ? code : null;\n }\n async function readHttpErrorInfo(response) {\n let rawBody;\n try {\n rawBody = await response.text();\n } catch (error48) {\n if (error48 instanceof BbRequestTimeoutError) {\n throw error48;\n }\n rawBody = \"\";\n }\n const normalized = rawBody.replace(/\\s+/g, \" \").trim();\n if (normalized.length === 0) {\n return { code: null, message: response.statusText };\n }\n const contentType = response.headers.get(\"content-type\");\n const shouldParseJson = (contentType?.includes(\"application/json\") ?? false) || normalized.startsWith(\"{\") || normalized.startsWith(\"[\");\n if (!shouldParseJson) {\n return { code: null, message: normalized };\n }\n try {\n const parsed = JSON.parse(normalized);\n return {\n code: readHttpErrorCode(parsed),\n message: extractErrorMessage(parsed, ERROR_EXTRACT_OPTS) ?? normalized\n };\n } catch {\n return { code: null, message: normalized };\n }\n }\n\n // src/transport.ts\n function buildApiUrl(args) {\n return `${args.baseUrl.replace(/\\/$/u, \"\")}/api/v1${args.path}`;\n }\n\n // src/transport-http.ts\n var SAME_ORIGIN_BASE_URL = \"\";\n function createHttpTransport(args) {\n const baseUrl = args.baseUrl ?? SAME_ORIGIN_BASE_URL;\n const fetchImpl = args.fetch ?? fetch;\n const client = createApiClient(baseUrl, { fetch: fetchImpl });\n return {\n api: client.api,\n baseUrl,\n fetch: fetchImpl,\n ...args.realtimeUrl ? { realtimeUrl: args.realtimeUrl } : {},\n runtime: args.runtime,\n websocket: args.websocket,\n readJson: (response) => readJsonResponse({ response }),\n readVoid: (response) => readVoidResponse({ response }),\n resolve: (response) => resolveResponse({ response })\n };\n }\n function fetchApi(args, transport) {\n return transport.fetch(buildApiUrl({ baseUrl: transport.baseUrl, path: args.path }), {\n body: args.body,\n headers: args.headers,\n method: args.method\n });\n }\n\n // src/areas/common.ts\n function requireCurrentApplicationId(context) {\n if (!context.applicationId) {\n throw new Error(\"current_app_unavailable\");\n }\n return context.applicationId;\n }\n\n // src/areas/apps.ts\n var APP_MISSING_ERROR_CODE = \"app_missing\";\n function isAppDataPathMissingError(error48) {\n return error48 instanceof BbHttpError && error48.status === 404 && error48.code !== APP_MISSING_ERROR_CODE;\n }\n function encodePathSegments(value) {\n return value.split(\"/\").map(encodeURIComponent).join(\"/\");\n }\n function appDataPath(args) {\n return `/apps/${encodeURIComponent(args.applicationId)}/data/${encodePathSegments(\n args.path\n )}`;\n }\n function appEntryPath(args) {\n const path = `/api/v1/apps/${encodeURIComponent(args.applicationId)}/`;\n if (!args.targetThreadId) {\n return path;\n }\n return `${path}?targetThreadId=${encodeURIComponent(args.targetThreadId)}`;\n }\n function createAppsArea(args) {\n const { transport } = args;\n const data = {\n async delete(input) {\n await transport.readVoid(\n fetchApi(\n {\n method: \"DELETE\",\n path: appDataPath(input),\n headers: { Accept: \"application/json\" }\n },\n transport\n )\n );\n return { ok: true };\n },\n async list(input) {\n return transport.readJson(\n transport.api.v1.apps[\":applicationId\"].data.$get({\n param: { applicationId: input.applicationId },\n query: input.prefix === void 0 ? {} : { prefix: input.prefix }\n })\n );\n },\n async read(input) {\n try {\n const response = await transport.resolve(\n fetchApi(\n {\n method: \"GET\",\n path: appDataPath(input),\n headers: { Accept: \"application/json\" }\n },\n transport\n )\n );\n return appDataReadResponseSchema.parse(await response.json());\n } catch (error48) {\n if (isAppDataPathMissingError(error48)) {\n return void 0;\n }\n throw error48;\n }\n },\n async write(input) {\n const response = await transport.resolve(\n fetchApi(\n {\n method: \"PUT\",\n path: appDataPath(input),\n headers: {\n Accept: \"application/json\",\n \"Content-Type\": \"application/json\"\n },\n body: JSON.stringify({ value: input.value })\n },\n transport\n )\n );\n return appDataReadResponseSchema.parse(await response.json());\n }\n };\n return {\n async create(input) {\n return transport.readJson(\n transport.api.v1.apps.$post({\n json: input\n })\n );\n },\n async current() {\n return {\n applicationId: requireCurrentApplicationId(args.context),\n appDataPath: args.context.appDataPath,\n appRootPath: args.context.appRootPath,\n appsRootPath: args.context.appsRootPath\n };\n },\n data,\n async delete(input) {\n await transport.readVoid(\n transport.api.v1.apps[\":applicationId\"].$delete({\n param: { applicationId: input.applicationId }\n })\n );\n return { ok: true };\n },\n async get(input) {\n return transport.readJson(\n transport.api.v1.apps[\":applicationId\"].$get({\n param: { applicationId: input.applicationId }\n })\n );\n },\n async list() {\n return transport.readJson(transport.api.v1.apps.$get());\n },\n async message(input) {\n const json2 = {\n payload: input.payload,\n ...input.appSessionToken ? { appSessionToken: input.appSessionToken } : {},\n ...input.targetThreadId ? { targetThreadId: input.targetThreadId } : {}\n };\n await transport.readVoid(\n transport.api.v1.apps[\":applicationId\"].message.$post({\n param: { applicationId: input.applicationId },\n json: json2\n })\n );\n return { ok: true };\n },\n openUrl(input) {\n return appEntryPath(input);\n }\n };\n }\n function createCurrentAppDataArea(args) {\n const { apps } = args;\n const applicationId = () => requireCurrentApplicationId(args.context);\n const entries = async (input = {}) => {\n const response = await apps.data.list({\n applicationId: applicationId(),\n prefix: input.prefix\n });\n return response.entries;\n };\n return {\n async delete(input) {\n await apps.data.delete({\n applicationId: applicationId(),\n path: input.path\n });\n },\n entries,\n async list(input = {}) {\n const appDataEntries = await entries(input);\n return appDataEntries.map((entry) => ({\n path: entry.path,\n value: entry.value\n }));\n },\n onChange(input) {\n return args.realtime.on({\n event: \"app-data:changed\",\n applicationId: applicationId(),\n ...input.prefix === void 0 ? {} : { prefix: input.prefix },\n callback(event) {\n input.callback({\n path: event.path,\n value: event.deleted ? void 0 : event.value,\n deleted: event.deleted\n });\n }\n });\n },\n async read(input) {\n const entry = await apps.data.read({\n applicationId: applicationId(),\n path: input.path\n });\n return entry?.value;\n },\n async write(input) {\n await apps.data.write({\n applicationId: applicationId(),\n path: input.path,\n value: input.value\n });\n }\n };\n }\n function createCurrentAppMessageArea(args) {\n const apps = createAppsArea(args);\n return {\n async send(input) {\n await apps.message({\n applicationId: requireCurrentApplicationId(args.context),\n appSessionToken: args.context.appSessionToken,\n payload: input.payload,\n targetThreadId: input.targetThreadId ?? args.context.targetThreadId\n });\n }\n };\n }\n\n // src/areas/environments.ts\n function environmentUpdateJson(args) {\n return {\n mergeBaseBranch: args.mergeBaseBranch\n };\n }\n function environmentStatusQuery(args) {\n return {\n mergeBaseBranch: args.mergeBaseBranch\n };\n }\n function environmentDiffQuery(args) {\n switch (args.target) {\n case \"uncommitted\":\n return { target: args.target };\n case \"branch_committed\":\n case \"all\":\n return { target: args.target, mergeBaseBranch: args.mergeBaseBranch };\n case \"commit\":\n return { target: args.target, sha: args.sha };\n }\n }\n function environmentDiffFileQuery(args) {\n switch (args.target) {\n case \"uncommitted\":\n return {\n path: args.path,\n side: args.side,\n target: args.target\n };\n case \"branch_committed\":\n case \"all\":\n return {\n mergeBaseRef: args.mergeBaseRef,\n path: args.path,\n side: args.side,\n target: args.target\n };\n case \"commit\":\n return {\n path: args.path,\n sha: args.sha,\n side: args.side,\n target: args.target\n };\n }\n }\n function environmentDiffBranchesQuery(args) {\n return {\n ...args.query !== void 0 ? { query: args.query } : {},\n ...args.limit !== void 0 ? { limit: args.limit } : {}\n };\n }\n function createEnvironmentsArea(args) {\n const { transport } = args;\n return {\n async commit(input) {\n const body = await transport.readJson(\n transport.api.v1.environments[\":id\"].actions.$post({\n param: { id: input.environmentId },\n json: {\n action: \"commit\"\n }\n })\n );\n return commitActionResponseSchema.parse(body);\n },\n async diff(input) {\n return transport.readJson(\n transport.api.v1.environments[\":id\"].diff.$get({\n param: { id: input.environmentId },\n query: environmentDiffQuery(input)\n })\n );\n },\n async diffBranches(input) {\n return transport.readJson(\n transport.api.v1.environments[\":id\"].diff.branches.$get({\n param: { id: input.environmentId },\n query: environmentDiffBranchesQuery(input)\n })\n );\n },\n async diffFile(input) {\n return transport.readJson(\n transport.api.v1.environments[\":id\"].diff.file.$get({\n param: { id: input.environmentId },\n query: environmentDiffFileQuery(input)\n })\n );\n },\n async get(input) {\n const body = await transport.readJson(\n transport.api.v1.environments[\":id\"].$get({\n param: { id: input.environmentId }\n })\n );\n return environmentSchema.parse(body);\n },\n async squashMerge(input) {\n const body = await transport.readJson(\n transport.api.v1.environments[\":id\"].actions.$post({\n param: { id: input.environmentId },\n json: {\n action: \"squash_merge\",\n options: {\n mergeBaseBranch: input.mergeBaseBranch\n }\n }\n })\n );\n return squashMergeActionResponseSchema.parse(body);\n },\n async status(input) {\n return transport.readJson(\n transport.api.v1.environments[\":id\"].status.$get({\n param: { id: input.environmentId },\n query: environmentStatusQuery(input)\n })\n );\n },\n async update(input) {\n return transport.readJson(\n transport.api.v1.environments[\":id\"].$patch({\n param: { id: input.environmentId },\n json: environmentUpdateJson(input)\n })\n );\n }\n };\n }\n\n // bb-guide-template-definitions:bb-guide-template-definitions\n var templateDefinitions = [{ \"id\": \"bbGuideApp\", \"body\": 'Apps\\n\\nApps are global within the local host data directory. They are the supported\\nway to build dashboards, control panels, and other interactive surfaces that\\ncan open inside a thread panel.\\n\\nImportant: bb serves each app\\'s committed `public/` directory as a static web\\nroot at `/api/v1/apps//`. New apps created with `bb app new`\\nstart as a Vite + React + TypeScript Todo app with an editable `source/`\\nproject and a prebuilt `public/` output, so they render immediately.\\n\\nEdit scaffolded apps in `source/`, then rebuild to `public/`. A Vite dev server\\nis useful while editing, but bb serves only `public/`; do not rely on a running\\nlocalhost server for the installed app.\\n\\nStorage layout:\\n\\n```text\\n/\\n apps/\\n review-board/\\n manifest.json\\n README.md\\n public/\\n index.html\\n index-abc.js\\n index-def.css\\n data/\\n state.json\\n skills/\\n add-todos/\\n SKILL.md\\n source/\\n package.json\\n vite.config.ts\\n src/\\n```\\n\\nEach app is rooted at `/apps//`. The manifest lives at\\n`manifest.json`, browser files live under `public/`, and durable JSON state\\nlives under `data/`. Only `public/` is served as static web content. `source/`\\nand `skills/` are local app files for editing and agent workflows; they are not\\nserved as browser content.\\n\\nThe app exists only when the local filesystem contains a valid manifest at\\n`/apps//manifest.json`. `manifest.id` is the canonical\\napplication id: it must be a lowercase path-safe slug such as `status` or\\n`review-board`, globally unique inside the data dir, and equal to the\\ncontaining folder name. `manifest.name` is an optional human display name only.\\nWhen it is absent or empty, bb displays the slug. Display names are not\\nidentifiers and may repeat.\\n\\nManifest:\\n\\n```json\\n{\\n \"manifestVersion\": 1,\\n \"id\": \"review-board\",\\n \"name\": \"Review Board\",\\n \"icon\": \"ListTodo\",\\n \"entry\": \"index.html\",\\n \"capabilities\": [\"data\", \"message\"]\\n}\\n```\\n\\n`entry` is relative to `public/`. HTML entries load in an app iframe and receive\\nthe prototype `window.bb` SDK; Markdown entries render as static documents and\\ndo not receive `window.bb`. `capabilities` is retained as manifest metadata, but\\nthe Phase 1 SDK prototype does not gate browser helpers by capability.\\n\\nThe served app entry URL is `/api/v1/apps//`; bb serves\\n`public/` transparently from that same URL root. Browser files in `public/`\\ntherefore resolve by normal browser URL rules with no `` injection and no\\nserve-time URL rewriting:\\n`public/index-abc.js` maps to `/api/v1/apps//index-abc.js`, and\\n`public/assets/index-def.css` maps to\\n`/api/v1/apps//assets/index-def.css`.\\n\\nFor Vite builds, set a relative base and build directly into `public/`:\\n\\n```ts\\nimport { defineConfig } from \"vite\";\\nimport react from \"@vitejs/plugin-react\";\\nimport tailwindcss from \"@tailwindcss/vite\";\\n\\nexport default defineConfig({\\n plugins: [react(), tailwindcss()],\\n base: \"./\",\\n build: {\\n outDir: \"../public\",\\n assetsDir: \"\",\\n emptyOutDir: true,\\n },\\n});\\n```\\n\\nDo not use Vite\\'s default root-absolute base (`\"/\"`). Refs such as\\n`/assets/index-abc.js` resolve against the bb server root, not the app route, so\\nthey will not load inside a mounted app.\\n\\nTo edit a scaffolded app:\\n\\n```bash\\ncd \"$BB_APP_ROOT/source\"\\npnpm install\\npnpm build\\n```\\n\\n`pnpm build` writes `../public/index.html` and flat relative assets beside it.\\nCommit or keep those `public/` files in the app directory so the app opens\\nwithout a build step at runtime.\\n\\nThe icon is optional and uses a built-in icon name. Icon resolution order is:\\n\\n1. `manifest.icon`, when present, as a built-in icon.\\n2. A custom top-level `logo.svg`, `logo.png`, `logo.jpg`, or `logo.jpeg` in the\\n app root, up to 1 MB.\\n3. The built-in `GridView` fallback.\\n\\nCLI:\\n\\n```bash\\nbb app list\\nbb app new --name \"Review Board\"\\nbb app new --slug status\\nbb app show review-board\\nbb app data list review-board\\nbb app data read review-board state.json\\nbb app data write review-board state.json --file ./state.json\\nbb app message review-board --target-thread thr_123 --json \\'\"Please review the current blockers.\"\\'\\nbb app delete review-board --yes\\n```\\n\\n`--json` is available for scripts. Commands accept application ids only, never\\ndisplay names. There is no host selector in v1; apps are local-host only.\\n\\nInside an app-capable runtime, inspect the current app context:\\n\\n```bash\\nbb app current --json\\n```\\n\\nOutside a current-app runtime, this returns `current_app_unavailable`.\\n\\nRuntime paths:\\n\\n```bash\\necho \"$BB_APPS_ROOT\" # /apps\\necho \"$BB_APP_ID\" # current application id, when available\\necho \"$BB_APP_ROOT\" # /apps/, when available\\necho \"$BB_APP_DATA_PATH\" # /apps//data, when available\\n```\\n\\nAgent writes:\\n\\nWhen a runtime has `BB_APP_ROOT`, edit the app directly in that canonical\\nfolder. Write app data through the app data API or with a temp file in the same\\ndirectory and then `mv` into place. Same-directory rename is atomic on macOS and\\nLinux, and bb broadcasts the committed app-data change.\\n\\n```bash\\ndir=\"$BB_APP_DATA_PATH\"\\nmkdir -p \"$dir\"\\ntmp=$(mktemp \"$dir/.state.XXXXXX\")\\nprintf \\'%s\\\\n\\' \\'{\"tasks\":[],\"updatedAt\":\"2026-06-02T00:00:00Z\"}\\' > \"$tmp\" &&\\n mv \"$tmp\" \"$dir/state.json\"\\n```\\n\\nThe default Todo scaffold also installs `skills/add-todos/SKILL.md`. Its todo\\nrecords live at `todos/` and have this shape:\\n\\n```json\\n{\\n \"id\": \"todo_20260603_review_notes\",\\n \"title\": \"Review notes from the manager\",\\n \"done\": false,\\n \"createdAt\": \"2026-06-03T20:00:00.000Z\",\\n \"updatedAt\": \"2026-06-03T20:00:00.000Z\"\\n}\\n```\\n\\nWrite one from an agent or script with:\\n\\n```bash\\nprintf \\'%s\\\\n\\' \\'{\"id\":\"todo_20260603_review_notes\",\"title\":\"Review notes from the manager\",\"done\":false,\"createdAt\":\"2026-06-03T20:00:00.000Z\",\"updatedAt\":\"2026-06-03T20:00:00.000Z\"}\\' |\\n bb app data write review-board todos/todo_20260603_review_notes --stdin\\n```\\n\\nData paths are relative to the app\\'s `data/` directory. They must not start or\\nend with `/`, must not contain backslashes, dot-prefixed segments, `.` or `..`,\\nand may be nested up to eight path segments. Each segment may use letters,\\nnumbers, dots, underscores, and hyphens.\\n\\nBrowser API:\\n\\n```ts\\nwindow.bb.applicationId\\nwindow.bb.appId\\nawait window.bb.data.read({ path: \"state.json\" })\\nawait window.bb.data.write({ path: \"state.json\", value: { tasks: [] } })\\nawait window.bb.data.delete({ path: \"state.json\" })\\nconst entries = await window.bb.data.list({ prefix: \"\" })\\nconst unsubscribe = window.bb.data.onChange({ prefix: \"\", callback(event) {\\n console.log(event.path, event.value, event.deleted)\\n}})\\nawait window.bb.message.send({ payload: \"Please review the current blockers.\" })\\n```\\n\\n`window.bb.data` reads and writes JSON values. `onChange({ prefix, callback })`\\nmatches a single data file when `prefix` equals that path and matches a subtree\\nwhen the changed path is below `prefix + \"/\"`; `\"\"` matches all app data.\\nRegistering a listener immediately replays existing matching data, and bb\\nreplays again after reconnects or app-data resync hints. Later filesystem\\nwrites, browser writes, and deletes are delivered after that replay.\\n\\n`window.bb.message.send({ payload })` sends a normal follow-up message to the\\nthread context that opened the app. Non-iframe callers must provide a target\\nthread through the message API or CLI; without a target, bb returns\\n`message_target_required`. App data remains global. Only message delivery is\\ncontextual.\\n\\nMinimal app-data pattern:\\n\\n```ts\\nconst entries = await window.bb.data.list({ prefix: \"todos\" });\\n\\nconst unsubscribe = window.bb.data.onChange({\\n prefix: \"todos\",\\n callback(event) {\\n console.log(event.path, event.value, event.deleted);\\n },\\n});\\n\\nawait window.bb.data.write({\\n path: \"todos/todo_20260603_review_notes\",\\n value: {\\n id: \"todo_20260603_review_notes\",\\n title: \"Review notes from the manager\",\\n done: false,\\n createdAt: \"2026-06-03T20:00:00.000Z\",\\n updatedAt: \"2026-06-03T20:00:00.000Z\",\\n },\\n});\\n```\\n\\nStyling:\\n\\nMake app UI quiet, dense, and consistent with bb unless the user asks for a\\ndifferent direction. Use Tailwind for layout utilities if helpful, and use the\\nbb-style tokens below for colors, fonts, borders, radius, and shadows. Apps\\nrender in iframes, so external resources such as Google Fonts, Tailwind CDN,\\nremote images, and stylesheets load normally.\\n\\n```html\\n