@agimon-ai/po-web-components 0.0.0-alpha.2 → 0.0.0-alpha.4

package/README.md

@@ -13,7 +13,7 @@ Because every colour is a token, a theme config recolours the whole cockpit at r
 | `.`               | Actions and chips: `Button`, `Badge`, `StatusBadge`, `Dot`, `Kbd`, `NavTab*`, `Tabs*`. Fields: `Input`, `Textarea`, `Label`, `Checkbox`, `Switch`, `RadioGroup*`, `Select*`. Overlays: `Dialog*`, `Sheet*`, `Popover*`, `DropdownMenu*`, `Tooltip*`, `Toast*`, `Command*`. Layout and content: `Panel*`, `SectionLabel`, `Separator`, `EmptyState`, `ScrollArea`, `Collapsible*`, `Accordion*`, `OptionList`, `OptionRow`, `MessageItem*`, `MessageLines`. Feedback: `Spinner`, `Progress`, `Skeleton`, `Avatar*`, `StreamCursor`. Files: `CodeEditor`, `MediaPreview`. Review: `DiffView`, `ReviewCommentDraft`. Plus the curated icon set, `cn`, `collapseLines`, `grammarKeyOf`, `mediaKindOf`, the review helpers (`buildReviewPrompt`, `reviewCommentAnchor`, `diffRangeOf`), `groupByDirectory`, the option-list key helpers, and the tone vocabularies with the maps between them |
 | `./theme`         | `ThemeConfig`, the token lists, `BUILTIN_THEMES`, `applyTheme`, `parseThemeConfig`, `themeFromPiTheme`, the stored-preference helpers                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
 | `./styles.css`    | The token stylesheet: the bundled fonts, then `styles/theme.css` (`:root` defaults, the Tailwind `@theme inline` mapping, shadcn semantic aliases, base styles, and the `@source` for this package's classes)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
-| `./themes/*.json` | The shipped theme configs: `doom-one-dark` (default), `doom-one-light`, `doom-nord-dark`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| `./themes/*.json` | The shipped theme configs: `po-one-dark` (default), `po-one-light`, `po-nord-dark`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
 
 ## Using it from the cockpit host
 
@@ -27,7 +27,7 @@ Because every colour is a token, a theme config recolours the whole cockpit at r
 import { Button, Dialog, DialogContent, StatusBadge } from '@agimon-ai/po-web-components';
 import { applyTheme, builtinTheme, readThemePreference } from '@agimon-ai/po-web-components/theme';
 
-applyTheme(builtinTheme(readThemePreference(localStorage) ?? 'doom-one-dark')!, document.documentElement);
+applyTheme(builtinTheme(readThemePreference(localStorage) ?? 'po-one-dark')!, document.documentElement);
 ```
 
 ## Tones
@@ -56,7 +56,7 @@ is what keeps host and plugin items alike, and the shell carries the `tool-statu
 
 ## Files
 
-`CodeEditor` is CodeMirror 6 on the doom palette: line numbers, folding, undo, a search panel, and
+`CodeEditor` is CodeMirror 6 on the po palette: line numbers, folding, undo, a search panel, and
 a grammar chosen from the file's path. It arrives as its own chunk, and each grammar as another, so
 a session that never opens a file downloads neither. Give it a height (it fills its container) and
 read edits back through `onChange`; `onSelect` reports the current range with one-based line
@@ -95,7 +95,7 @@ places inline content, such as an open draft, under a row.
 A web plugin's client code may import `react`, the `@tanstack` store packages,
 `@agimon-ai/po-core/web`, and this package. Declare it as a `workspace:*` dependency and
 import the same way the host does; the cockpit bundler dedupes it so one copy renders everywhere.
-Do not import `radix-ui` or `class-variance-authority` directly from plugin code: the doom-web
+Do not import `radix-ui` or `class-variance-authority` directly from plugin code: the po-web
 vibe-lint rules route every primitive through this package so a theme change reaches all of them.
 
 ## Theme tokens
@@ -133,8 +133,8 @@ ink; the role ladder is in [docs/design.md](../../../docs/design.md#type). `./mc
 same tokens without the fonts: a Po-generated MCP app gets them inlined by its build, and a
 third-party app keeps its own.
 
-Each token is published as `--doom-<token>` on the root element and mapped to Tailwind as
-`doom-<token>` (`bg-doom-panel`, `text-doom-hi`, `border-doom-edge-red`), and to shadcn's semantic
+Each token is published as `--po-<token>` on the root element and mapped to Tailwind as
+`po-<token>` (`bg-po-panel`, `text-po-hi`, `border-po-edge-red`), and to shadcn's semantic
 names (`bg-background`, `text-muted-foreground`, `border-input`).
 
 ## Writing a theme
@@ -160,6 +160,6 @@ pnpm test       # theme, bridge, and render smoke tests (react-dom/server, no DO
 pnpm typecheck
 ```
 
-The `doom-web` vibe-lint preset governs the layout: `src/types` (the theme contract), `src/lib`
+The `po-web` vibe-lint preset governs the layout: `src/types` (the theme contract), `src/lib`
 (`cn`), `src/theme`, `src/icons`, `src/components` (one PascalCase component per file, props-driven,
 no application state), and `src/exports` (pure re-exports, one file per subpath).

package/dist/node_modules/.pnpm/{@modelcontextprotocol_server@2.2.0/node_modules/@modelcontextprotocol/server/dist/createMcpHandler-CfX6zgs1.d.mts → @modelcontextprotocol_server@2.3.1/node_modules/@modelcontextprotocol/server/dist/createMcpHandler-D4NN8WsG.d.mts}

@@ -1,8 +1,7 @@
-import { infer as output } from "../../../../../zod@4.6.5/node_modules/zod/v4/core/core.mjs";
-import { ZodTypeAny } from "../../../../../zod@4.6.5/node_modules/zod/v4/classic/compat.mjs";
-import { index_d_exports } from "../../../../../zod@4.6.5/node_modules/zod/v4/index.mjs";
+import { infer as output } from "../../../../../zod@4.6.6/node_modules/zod/v4/core/core.mjs";
+import { ZodTypeAny } from "../../../../../zod@4.6.6/node_modules/zod/v4/classic/compat.mjs";
 import { CallToolResultSchema } from "@modelcontextprotocol/core/internal";
-//#region ../../../node_modules/.pnpm/@modelcontextprotocol+server@2.2.0/node_modules/@modelcontextprotocol/server/dist/createMcpHandler-CfX6zgs1.d.mts
+//#region ../../../node_modules/.pnpm/@modelcontextprotocol+server@2.3.1/node_modules/@modelcontextprotocol/server/dist/createMcpHandler-D4NN8WsG.d.mts
 type Primitive = string | number | boolean | bigint | null | undefined;
 type Flatten<T$1> = T$1 extends Primitive ? T$1 : T$1 extends Array<infer U> ? Array<Flatten<U>> : T$1 extends Set<infer U> ? Set<Flatten<U>> : T$1 extends Map<infer K, infer V> ? Map<Flatten<K>, Flatten<V>> : T$1 extends object ? { [K in keyof T$1]: Flatten<T$1[K]>; } : T$1;
 type Infer<Schema extends ZodTypeAny> = Flatten<output<Schema>>;
@@ -23,5 +22,5 @@ type WireOnlyResultKey = 'resultType';
 type StripWireOnly<T$1> = T$1 extends unknown ? { [K in keyof T$1 as K extends WireOnlyResultKey ? never : K]: T$1[K]; } : never;
 type CallToolResult = StripWireOnly<Infer<typeof CallToolResultSchema>>;
 //#endregion
-export { CallToolResult as ln };
-//# sourceMappingURL=createMcpHandler-CfX6zgs1.d.mts.map
+export { CallToolResult as un };
+//# sourceMappingURL=createMcpHandler-D4NN8WsG.d.mts.map

package/dist/node_modules/.pnpm/@modelcontextprotocol_server@2.3.1/node_modules/@modelcontextprotocol/server/dist/createMcpHandler-D4NN8WsG.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createMcpHandler-D4NN8WsG.d.mts","names":["z.ZodTypeAny","z.infer"],"sources":["../../../../../../../../../../../node_modules/.pnpm/@modelcontextprotocol+server@2.3.1/node_modules/@modelcontextprotocol/server/dist/createMcpHandler-D4NN8WsG.d.mts"],"ignoreList":[0],"mappings":";;;;KA2UK;KACA,QAAQ,OAAO,YAAY,YAAY,MAAM,YAAY,YAAY,KAAK,MAAM,QAAQ,MAAM,YAAY,UAAU,KAAK,IAAI,QAAQ,MAAM,YAAY,UAAU,SAAS,KAAK,IAAI,QAAQ,IAAI,QAAQ,MAAM,wBAAwB,WAAW,MAAM,QAAQ,IAAI,SAAQ;KAC1Q,MAAM,eAAeA,cAAgB,QAAQC,OAAQ;;;;;;;;;KASrD;;;;;;KAMA,cAAc,OAAO,yBAAyB,WAAW,OAAO,UAAU,4BAA4B,IAAI,IAAI;KAgK9G,iBAAiB,cAAc,aAAa"}

package/dist/node_modules/.pnpm/@modelcontextprotocol_server@2.3.1/node_modules/@modelcontextprotocol/server/dist/index.d.mts

@@ -0,0 +1,2 @@
+import { un as CallToolResult } from "./createMcpHandler-D4NN8WsG.mjs";
+export { CallToolResult };

package/dist/node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/classic/compat.d.mts

@@ -0,0 +1,8 @@
+import { $ZodTypeInternals } from "../core/schemas.mjs";
+import { $brand } from "../core/core.mjs";
+import { ZodType } from "./schemas.mjs";
+//#region ../../../node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/classic/compat.d.cts
+/** @deprecated Use z.ZodType (without generics) instead. */
+export type ZodTypeAny<Output = unknown, Input = unknown, Internals extends $ZodTypeInternals<Output, Input> = $ZodTypeInternals<Output, Input>> = ZodType<Output, Input, Internals>;
+//#endregion
+//# sourceMappingURL=compat.d.mts.map

package/dist/node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/classic/compat.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compat.d.mts","names":["core.$ZodTypeInternals"],"sources":["../../../../../../../../../../../node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/classic/compat.d.cts"],"ignoreList":[0],"mappings":";;;;;YAsCY,WAAW,kBAAkB,iBAAiB,kBAAkBA,kBAAuB,QAAQ,SAASA,kBAAuB,QAAQ,UAAU,QAAQ,QAAQ,OAAO"}

package/dist/node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/classic/errors.d.mts

@@ -0,0 +1,21 @@
+import { $ZodError, $ZodFlattenedError, $ZodFormattedError, $ZodIssue } from "../core/errors.mjs";
+import { $constructor } from "../core/core.mjs";
+//#region ../../../node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/classic/errors.d.cts
+/** An Error-like class used to store Zod validation issues.  */
+export interface ZodError<T = unknown> extends $ZodError<T> {
+  /** @deprecated Use the `z.treeifyError(err)` function instead. */
+  format(): $ZodFormattedError<T>;
+  format<U>(mapper: (issue: $ZodIssue) => U): $ZodFormattedError<T, U>;
+  /** @deprecated Use the `z.treeifyError(err)` function instead. */
+  flatten(): $ZodFlattenedError<T>;
+  flatten<U>(mapper: (issue: $ZodIssue) => U): $ZodFlattenedError<T, U>;
+  /** @deprecated Push directly to `.issues` instead. */
+  addIssue(issue: $ZodIssue): void;
+  /** @deprecated Push directly to `.issues` instead. */
+  addIssues(issues: $ZodIssue[]): void;
+  /** @deprecated Check `err.issues.length === 0` instead. */
+  isEmpty: boolean;
+}
+export declare const ZodError: $constructor<ZodError>;
+//#endregion
+//# sourceMappingURL=errors.d.mts.map

package/dist/node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/classic/errors.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.mts","names":["core.$ZodFormattedError","core.$ZodIssue","core.$ZodFlattenedError","core.$constructor"],"sources":["../../../../../../../../../../../node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/classic/errors.d.cts"],"ignoreList":[0],"mappings":";;;;iBAKiB,SAAS,qBAAqB,UAAU;;EAErD,UAAUA,mBAAwB;EAClC,OAAO,GAAG,SAAS,OAAOC,cAAmB,IAAID,mBAAwB,GAAG;;EAE5E,WAAWE,mBAAwB;EACnC,QAAQ,GAAG,SAAS,OAAOD,cAAmB,IAAIC,mBAAwB,GAAG;;EAE7E,SAAS,OAAOD;;EAEhB,UAAU,QAAQA;;EAElB;;qBAEiB,UAAUE,aAAkB"}

package/dist/node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/classic/parse.d.mts

@@ -0,0 +1,15 @@
+import { ZodError } from "./errors.mjs";
+//#region ../../../node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/classic/parse.d.cts
+export type ZodSafeParseResult<T> = ZodSafeParseSuccess<T> | ZodSafeParseError<T>;
+export type ZodSafeParseSuccess<T> = {
+  success: true;
+  data: T;
+  error?: never;
+};
+export type ZodSafeParseError<T> = {
+  success: false;
+  data?: never;
+  error: ZodError<T>;
+};
+//#endregion
+//# sourceMappingURL=parse.d.mts.map

package/dist/node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/classic/parse.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.mts","names":[],"sources":["../../../../../../../../../../../node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/classic/parse.d.cts"],"ignoreList":[0],"mappings":";;YAEY,mBAAmB,KAAK,oBAAoB,KAAK,kBAAkB;YACnE,oBAAoB;EAC5B;EACA,MAAM;EACN;;YAEQ,kBAAkB;EAC1B;EACA;EACA,OAAO,SAAS"}

package/dist/node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/classic/schemas.d.mts

@@ -0,0 +1,169 @@
+import { StandardSchemaWithJSONProps } from "../core/standard-schema.mjs";
+import { $ZodRegistry, $replace, GlobalMeta } from "../core/registries.mjs";
+import { ToJSONSchemaParams, ZodStandardJSONSchemaPayload } from "../core/to-json-schema.mjs";
+import { NoUndefined } from "../core/util.mjs";
+import { $ZodArray, $ZodArrayInternals, $ZodCatch, $ZodCatchCtx, $ZodCatchInternals, $ZodDefault, $ZodDefaultInternals, $ZodExactOptional, $ZodExactOptionalInternals, $ZodIntersection, $ZodIntersectionInternals, $ZodNonOptional, $ZodNonOptionalInternals, $ZodNullable, $ZodNullableInternals, $ZodOptional, $ZodOptionalInternals, $ZodPipe, $ZodPipeInternals, $ZodPrefault, $ZodPrefaultInternals, $ZodReadonly, $ZodReadonlyInternals, $ZodTransform, $ZodTransformInternals, $ZodType, $ZodTypeInternals, $ZodUnion, $ZodUnionInternals, CheckFn, ParseContext, SomeType } from "../core/schemas.mjs";
+import { $ZodCheck } from "../core/checks.mjs";
+import { $ZodIssue } from "../core/errors.mjs";
+import { $ZodBranded, $constructor, infer as output, input } from "../core/core.mjs";
+import { $RefinementCtx, $ZodCheckLengthEqualsParams, $ZodCheckMaxLengthParams, $ZodCheckMinLengthParams, $ZodCustomParams, $ZodNonOptionalParams, $ZodSuperRefineParams } from "../core/api.mjs";
+import { ZodSafeParseResult } from "./parse.mjs";
+//#region ../../../node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/classic/schemas.d.cts
+export type ZodStandardSchemaWithJSON<T> = StandardSchemaWithJSONProps<input<T>, output<T>>;
+export interface ZodType<out Output = unknown, out Input = unknown, out Internals extends $ZodTypeInternals<Output, Input> = $ZodTypeInternals<Output, Input>> extends $ZodType<Output, Input, Internals> {
+  def: Internals["def"];
+  type: Internals["def"]["type"];
+  /** @deprecated Use `.def` instead. */
+  _def: Internals["def"];
+  /** @deprecated Use `z.output<typeof schema>` instead. */
+  _output: Internals["output"];
+  /** @deprecated Use `z.input<typeof schema>` instead. */
+  _input: Internals["input"];
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  /** Converts this schema to a JSON Schema representation. */
+  toJSONSchema(params?: ToJSONSchemaParams): ZodStandardJSONSchemaPayload<this>;
+  check(...checks: (CheckFn<output<this>> | $ZodCheck<output<this>>)[]): this;
+  with(...checks: (CheckFn<output<this>> | $ZodCheck<output<this>>)[]): this;
+  clone(def?: Internals["def"], params?: {
+    parent: boolean;
+  }): this;
+  register<R extends $ZodRegistry>(registry: R, ...meta: this extends R["_schema"] ? undefined extends R["_meta"] ? [$replace<R["_meta"], this>?] : [$replace<R["_meta"], this>] : ["Incompatible schema"]): this;
+  brand<T extends PropertyKey = PropertyKey, Dir extends "in" | "out" | "inout" = "out">(value?: T): PropertyKey extends T ? this : $ZodBranded<this, T, Dir>;
+  parse(data: unknown, params?: ParseContext<$ZodIssue>): output<this>;
+  safeParse(data: unknown, params?: ParseContext<$ZodIssue>): ZodSafeParseResult<output<this>>;
+  parseAsync(data: unknown, params?: ParseContext<$ZodIssue>): Promise<output<this>>;
+  safeParseAsync(data: unknown, params?: ParseContext<$ZodIssue>): Promise<ZodSafeParseResult<output<this>>>;
+  spa: (data: unknown, params?: ParseContext<$ZodIssue>) => Promise<ZodSafeParseResult<output<this>>>;
+  validate(data: unknown, params?: ParseContext<$ZodIssue>): data is input<this>;
+  validateAsync(data: unknown, params?: ParseContext<$ZodIssue>): Promise<boolean>;
+  encode(data: output<this>, params?: ParseContext<$ZodIssue>): input<this>;
+  decode(data: input<this>, params?: ParseContext<$ZodIssue>): output<this>;
+  encodeAsync(data: output<this>, params?: ParseContext<$ZodIssue>): Promise<input<this>>;
+  decodeAsync(data: input<this>, params?: ParseContext<$ZodIssue>): Promise<output<this>>;
+  safeEncode(data: output<this>, params?: ParseContext<$ZodIssue>): ZodSafeParseResult<input<this>>;
+  safeDecode(data: input<this>, params?: ParseContext<$ZodIssue>): ZodSafeParseResult<output<this>>;
+  safeEncodeAsync(data: output<this>, params?: ParseContext<$ZodIssue>): Promise<ZodSafeParseResult<input<this>>>;
+  safeDecodeAsync(data: input<this>, params?: ParseContext<$ZodIssue>): Promise<ZodSafeParseResult<output<this>>>;
+  refine<Ch extends (arg: output<this>) => unknown | Promise<unknown>>(check: Ch, params?: string | $ZodCustomParams): Ch extends ((arg: any) => arg is infer R) ? this & ZodType<R, input<this>> : this;
+  superRefine(refinement: (arg: output<this>, ctx: $RefinementCtx<output<this>>) => void | Promise<void>, params?: $ZodSuperRefineParams): this;
+  overwrite(fn: (x: output<this>) => output<this>): this;
+  optional(): ZodOptional<this>;
+  exactOptional(): ZodExactOptional<this>;
+  nonoptional(params?: string | $ZodNonOptionalParams): ZodNonOptional<this>;
+  nullable(): ZodNullable<this>;
+  nullish(): ZodOptional<ZodNullable<this>>;
+  default(def: NoUndefined<output<this>>): ZodDefault<this>;
+  default(def: () => NoUndefined<output<this>>): ZodDefault<this>;
+  prefault(def: () => input<this>): ZodPrefault<this>;
+  prefault(def: input<this>): ZodPrefault<this>;
+  array(): ZodArray<this>;
+  or<T extends SomeType>(option: T): ZodUnion<[this, T]>;
+  and<T extends SomeType>(incoming: T): ZodIntersection<this, T>;
+  transform<NewOut>(transform: (arg: output<this>, ctx: $RefinementCtx<output<this>>) => NewOut | Promise<NewOut>): ZodPipe<this, ZodTransform<Awaited<NewOut>, output<this>>>;
+  catch(def: output<this>): ZodCatch<this>;
+  catch(def: (ctx: $ZodCatchCtx) => output<this>): ZodCatch<this>;
+  pipe<T extends $ZodType<any, output<this>>>(target: T | $ZodType<any, output<this>>): ZodPipe<this, T>;
+  readonly(): ZodReadonly<this>;
+  /** Returns a new instance that has been registered in `z.globalRegistry` with the specified description */
+  describe(description: string): this;
+  description?: string;
+  /** Returns the metadata associated with this instance in `z.globalRegistry` */
+  meta(): $replace<GlobalMeta, this> | undefined;
+  /** Returns a new instance that has been registered in `z.globalRegistry` with the specified metadata */
+  meta(data: $replace<GlobalMeta, this>): this;
+  /** @deprecated Try safe-parsing `undefined` (this is what `isOptional` does internally):
+   *
+   * ```ts
+   * const schema = z.string().optional();
+   * const isOptional = schema.safeParse(undefined).success; // true
+   * ```
+   */
+  isOptional(): boolean;
+  /**
+   * @deprecated Try safe-parsing `null` (this is what `isNullable` does internally):
+   *
+   * ```ts
+   * const schema = z.string().nullable();
+   * const isNullable = schema.safeParse(null).success; // true
+   * ```
+   */
+  isNullable(): boolean;
+  apply<T, TArgs extends unknown[] = []>(fn: (schema: this, ...args: TArgs) => T, ...args: TArgs): T;
+}
+export interface _ZodType<out Internals extends $ZodTypeInternals = $ZodTypeInternals> extends ZodType<any, any, Internals> {}
+export declare const ZodType: $constructor<ZodType>;
+export interface ZodArray<T extends SomeType = $ZodType> extends _ZodType<$ZodArrayInternals<T>>, $ZodArray<T> {
+  element: T;
+  min(minLength: number, params?: string | $ZodCheckMinLengthParams): this;
+  nonempty(params?: string | $ZodCheckMinLengthParams): this;
+  max(maxLength: number, params?: string | $ZodCheckMaxLengthParams): this;
+  length(len: number, params?: string | $ZodCheckLengthEqualsParams): this;
+  unwrap(): T;
+  "~standard": ZodStandardSchemaWithJSON<this>;
+}
+export declare const ZodArray: $constructor<ZodArray>;
+export interface ZodUnion<T extends readonly SomeType[] = readonly $ZodType[]> extends _ZodType<$ZodUnionInternals<T>>, $ZodUnion<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  options: T;
+}
+export declare const ZodUnion: $constructor<ZodUnion>;
+export interface ZodIntersection<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends _ZodType<$ZodIntersectionInternals<A, B>>, $ZodIntersection<A, B> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+}
+export declare const ZodIntersection: $constructor<ZodIntersection>;
+export interface ZodTransform<O = unknown, I = unknown> extends _ZodType<$ZodTransformInternals<O, I>>, $ZodTransform<O, I> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+}
+export declare const ZodTransform: $constructor<ZodTransform>;
+export interface ZodOptional<T extends SomeType = $ZodType> extends _ZodType<$ZodOptionalInternals<T>>, $ZodOptional<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+export declare const ZodOptional: $constructor<ZodOptional>;
+export interface ZodExactOptional<T extends SomeType = $ZodType> extends _ZodType<$ZodExactOptionalInternals<T>>, $ZodExactOptional<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+export declare const ZodExactOptional: $constructor<ZodExactOptional>;
+export interface ZodNullable<T extends SomeType = $ZodType> extends _ZodType<$ZodNullableInternals<T>>, $ZodNullable<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+export declare const ZodNullable: $constructor<ZodNullable>;
+export interface ZodDefault<T extends SomeType = $ZodType> extends _ZodType<$ZodDefaultInternals<T>>, $ZodDefault<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+  /** @deprecated Use `.unwrap()` instead. */
+  removeDefault(): T;
+}
+export declare const ZodDefault: $constructor<ZodDefault>;
+export interface ZodPrefault<T extends SomeType = $ZodType> extends _ZodType<$ZodPrefaultInternals<T>>, $ZodPrefault<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+export declare const ZodPrefault: $constructor<ZodPrefault>;
+export interface ZodNonOptional<T extends SomeType = $ZodType> extends _ZodType<$ZodNonOptionalInternals<T>>, $ZodNonOptional<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+export declare const ZodNonOptional: $constructor<ZodNonOptional>;
+export interface ZodCatch<T extends SomeType = $ZodType> extends _ZodType<$ZodCatchInternals<T>>, $ZodCatch<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+  /** @deprecated Use `.unwrap()` instead. */
+  removeCatch(): T;
+}
+export declare const ZodCatch: $constructor<ZodCatch>;
+export interface ZodPipe<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends _ZodType<$ZodPipeInternals<A, B>>, $ZodPipe<A, B> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  in: A;
+  out: B;
+}
+export declare const ZodPipe: $constructor<ZodPipe>;
+export interface ZodReadonly<T extends SomeType = $ZodType> extends _ZodType<$ZodReadonlyInternals<T>>, $ZodReadonly<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+export declare const ZodReadonly: $constructor<ZodReadonly>;
+//#endregion
+//# sourceMappingURL=schemas.d.mts.map

package/dist/node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/classic/schemas.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.mts","names":["core.input","core.output","core.$ZodTypeInternals","core.ToJSONSchemaParams","core.ZodStandardJSONSchemaPayload","core.CheckFn","core.$ZodCheck","core.$ZodRegistry","core.$replace","core.$ZodBranded","core.$ZodIssue","core.ParseContext","parse.ZodSafeParseResult","core.$ZodCustomParams","core.$RefinementCtx","core.$ZodSuperRefineParams","core.$ZodNonOptionalParams","util.NoUndefined","core.SomeType","core.$ZodCatchCtx","core.$ZodType","core.GlobalMeta","core.$constructor","core.$ZodArrayInternals","core.$ZodCheckMinLengthParams","core.$ZodCheckMaxLengthParams","core.$ZodCheckLengthEqualsParams","core.$ZodArray","core.$ZodUnionInternals","core.$ZodUnion","core.$ZodIntersectionInternals","core.$ZodIntersection","core.$ZodTransformInternals","core.$ZodTransform","core.$ZodOptionalInternals","core.$ZodOptional","core.$ZodExactOptionalInternals","core.$ZodExactOptional","core.$ZodNullableInternals","core.$ZodNullable","core.$ZodDefaultInternals","core.$ZodDefault","core.$ZodPrefaultInternals","core.$ZodPrefault","core.$ZodNonOptionalInternals","core.$ZodNonOptional","core.$ZodCatchInternals","core.$ZodCatch","core.$ZodPipeInternals","core.$ZodPipe","core.$ZodReadonlyInternals","core.$ZodReadonly"],"sources":["../../../../../../../../../../../node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/classic/schemas.d.cts"],"ignoreList":[0],"mappings":"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"}

package/dist/node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/core/api.d.mts

@@ -0,0 +1,38 @@
+import { EmptyToNever, Flatten, MakePartial } from "./util.mjs";
+import { $ZodCustom, $ZodNonOptional, $ZodType, ParsePayload } from "./schemas.mjs";
+import { $ZodCheck, $ZodCheckLengthEquals, $ZodCheckMaxLength, $ZodCheckMinLength } from "./checks.mjs";
+import { $ZodErrorMap, $ZodIssue, $ZodIssueBase } from "./errors.mjs";
+//#region ../../../node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/core/api.d.cts
+export type Params<T extends $ZodType | $ZodCheck, IssueTypes extends $ZodIssueBase, OmitKeys extends keyof T["_zod"]["def"] = never> = Flatten<Partial<EmptyToNever<Omit<T["_zod"]["def"], OmitKeys> & ([IssueTypes] extends [never] ? {} : {
+  error?: string | $ZodErrorMap<IssueTypes> | undefined;
+  /** @deprecated This parameter is deprecated. Use `error` instead. */
+  message?: string | undefined;
+})>>>;
+export type TypeParams<T extends $ZodType = $ZodType & {
+  _isst: never;
+}, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "checks" | "error"> = never> = Params<T, NonNullable<T["_zod"]["isst"]>, "type" | "checks" | "error" | AlsoOmit>;
+export type CheckParams<T extends $ZodCheck = $ZodCheck, // & { _issc: never },
+  AlsoOmit extends Exclude<keyof T["_zod"]["def"], "check" | "error"> = never> = Params<T, NonNullable<T["_zod"]["issc"]>, "check" | "error" | AlsoOmit>;
+export type CheckTypeParams<T extends $ZodType & $ZodCheck = $ZodType & $ZodCheck, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "checks" | "error" | "check"> = never> = Params<T, NonNullable<T["_zod"]["isst"] | T["_zod"]["issc"]>, "type" | "checks" | "error" | "check" | AlsoOmit>;
+export type $ZodCheckMaxLengthParams = CheckParams<$ZodCheckMaxLength, "maximum" | "when">;
+export type $ZodCheckMinLengthParams = CheckParams<$ZodCheckMinLength, "minimum" | "when">;
+export type $ZodCheckLengthEqualsParams = CheckParams<$ZodCheckLengthEquals, "length" | "when">;
+export type $ZodNonOptionalParams = TypeParams<$ZodNonOptional, "innerType">;
+export type $ZodCustomParams = CheckTypeParams<$ZodCustom, "fn">;
+export type $ZodSuperRefineIssue<T extends $ZodIssueBase = $ZodIssue> = T extends any ? RawIssue<T> : never;
+type RawIssue<T extends $ZodIssueBase> = T extends any ? Flatten<MakePartial<T, "message" | "path"> & {
+  /** The schema or check that originated this issue. */
+  readonly inst?: $ZodType | $ZodCheck;
+  /** If `true`, Zod will execute subsequent checks/refinements instead of immediately aborting */
+  readonly continue?: boolean | undefined;
+} & Record<string, unknown>> : never;
+export interface $RefinementCtx<T = unknown> extends ParsePayload<T> {
+  addIssue(arg: string | $ZodSuperRefineIssue): void;
+}
+export interface $ZodSuperRefineParams {
+  /** If provided, the refinement runs only when this returns `true`. By default, it is skipped if prior parsing produced aborting issues. */
+  when?: ((payload: ParsePayload) => boolean) | undefined;
+}
+//#endregion
+export {};
+//# sourceMappingURL=api.d.mts.map

package/dist/node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/core/api.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.mts","names":["schemas.$ZodType","checks.$ZodCheck","errors.$ZodIssueBase","errors.$ZodErrorMap","util.EmptyToNever","util.Flatten","checks.$ZodCheckMaxLength","checks.$ZodCheckMinLength","checks.$ZodCheckLengthEquals","schemas.$ZodNonOptional","schemas.$ZodCustom","errors.$ZodIssue","util.MakePartial","schemas.ParsePayload"],"sources":["../../../../../../../../../../../node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/core/api.d.cts"],"ignoreList":[0],"mappings":";;;;;YAMY,OAAO,UAAUA,WAAmBC,WAAkB,mBAAmBC,eAAsB,uBAAuB,4BAA4BG,QAAa,QAAQD,aAAkB,KAAK,kBAAkB,cAAc;EACtO,iBAAiBD,aAAoB;;EAErC;;YAEQ,WAAW,UAAUH,WAAmBA;EAChD;GACD,iBAAiB,cAAc,0DAA0D,OAAO,GAAG,YAAY,kDAAkD;YACxJ,YAAY,UAAUC,YAAmBA;EACrD,iBAAiB,cAAc,gDAAgD,OAAO,GAAG,YAAY,wCAAwC;YAGjI,gBAAgB,UAAUD,WAAmBC,YAAmBD,WAAmBC,WAAkB,iBAAiB,cAAc,oEAAoE,OAAO,GAAG,YAAY,oBAAoB,4DAA4D;YAsL9S,2BAA2B,YAAYK;YAEvC,2BAA2B,YAAYC;YAEvC,8BAA8B,YAAYC;YA8E1C,wBAAwB,WAAWC;YAgBnC,mBAAmB,gBAAgBC;YAGnC,qBAAqB,UAAUR,gBAAuBS,aAAoB,gBAAgB,SAAS;KAC1G,SAAS,UAAUT,iBAAwB,gBAAgBG,QAAaO,YAAiB;;WAEjF,OAAOZ,WAAmBC;;WAE1B;IACT;iBACa,eAAe,qBAAqBY,aAAqB;EACtE,SAAS,cAAc;;iBAEV;;EAEb,SAAS,SAASA"}

package/dist/node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/core/checks.d.mts

@@ -0,0 +1,63 @@
+import { HasLength, MaybeAsync } from "./util.mjs";
+import { $ZodType, ParsePayload } from "./schemas.mjs";
+import { $ZodErrorMap, $ZodIssueBase, $ZodIssueTooBig, $ZodIssueTooSmall } from "./errors.mjs";
+import { $constructor } from "./core.mjs";
+//#region ../../../node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/core/checks.d.cts
+export interface $ZodCheckDef {
+  check: string;
+  error?: $ZodErrorMap<never> | undefined;
+  /** If true, no later checks will be executed if this check fails. Default `false`. */
+  abort?: boolean | undefined;
+  /** If provided, the check runs only when this returns `true`. By default, it is skipped if prior parsing produced aborting issues. */
+  when?: ((payload: ParsePayload) => boolean) | undefined;
+}
+export interface $ZodCheckInternals<T> {
+  def: $ZodCheckDef;
+  /** The set of issues this check might throw. */
+  issc?: $ZodIssueBase;
+  check(payload: ParsePayload<T>): MaybeAsync<void>;
+  onattach: ((schema: $ZodType) => void)[];
+}
+export interface $ZodCheck<in T = never> {
+  _zod: $ZodCheckInternals<T>;
+}
+export declare const $ZodCheck: $constructor<$ZodCheck<any>>;
+export interface $ZodCheckMaxLengthDef extends $ZodCheckDef {
+  check: "max_length";
+  maximum: number;
+}
+export interface $ZodCheckMaxLengthInternals<T extends HasLength = HasLength> extends $ZodCheckInternals<T> {
+  def: $ZodCheckMaxLengthDef;
+  issc: $ZodIssueTooBig<T>;
+}
+export interface $ZodCheckMaxLength<T extends HasLength = HasLength> extends $ZodCheck<T> {
+  _zod: $ZodCheckMaxLengthInternals<T>;
+}
+export declare const $ZodCheckMaxLength: $constructor<$ZodCheckMaxLength>;
+export interface $ZodCheckMinLengthDef extends $ZodCheckDef {
+  check: "min_length";
+  minimum: number;
+}
+export interface $ZodCheckMinLengthInternals<T extends HasLength = HasLength> extends $ZodCheckInternals<T> {
+  def: $ZodCheckMinLengthDef;
+  issc: $ZodIssueTooSmall<T>;
+}
+export interface $ZodCheckMinLength<T extends HasLength = HasLength> extends $ZodCheck<T> {
+  _zod: $ZodCheckMinLengthInternals<T>;
+}
+export declare const $ZodCheckMinLength: $constructor<$ZodCheckMinLength>;
+export interface $ZodCheckLengthEqualsDef extends $ZodCheckDef {
+  check: "length_equals";
+  length: number;
+}
+export interface $ZodCheckLengthEqualsInternals<T extends HasLength = HasLength> extends $ZodCheckInternals<T> {
+  def: $ZodCheckLengthEqualsDef;
+  issc: $ZodIssueTooBig<T> | $ZodIssueTooSmall<T>;
+}
+export interface $ZodCheckLengthEquals<T extends HasLength = HasLength> extends $ZodCheck<T> {
+  _zod: $ZodCheckLengthEqualsInternals<T>;
+}
+export declare const $ZodCheckLengthEquals: $constructor<$ZodCheckLengthEquals>;
+export type $ZodStringFormats = "email" | "url" | "emoji" | "uuid" | "guid" | "nanoid" | "cuid" | "cuid2" | "ulid" | "xid" | "ksuid" | "datetime" | "date" | "time" | "duration" | "ipv4" | "ipv6" | "cidrv4" | "cidrv6" | "base64" | "base64url" | "json_string" | "e164" | "credit_card" | "iban" | "lowercase" | "uppercase" | "regex" | "jwt" | "starts_with" | "ends_with" | "includes";
+//#endregion
+//# sourceMappingURL=checks.d.mts.map

package/dist/node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/core/checks.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checks.d.mts","names":["errors.$ZodErrorMap","schemas.ParsePayload","errors.$ZodIssueBase","util.MaybeAsync","schemas.$ZodType","core.$constructor","util.HasLength","errors.$ZodIssueTooBig","errors.$ZodIssueTooSmall"],"sources":["../../../../../../../../../../../node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/core/checks.d.cts"],"ignoreList":[0],"mappings":";;;;;iBAIiB;EACb;EACA,QAAQA;;EAER;;EAEA,SAAS,SAASC;;iBAEL,mBAAmB;EAChC,KAAK;;EAEL,OAAOC;EACP,MAAM,SAASD,aAAqB,KAAKE;EACzC,YAAY,QAAQC;;iBAEP,aAAa;EAC1B,MAAM,mBAAmB;;qBAER,WAAWC,aAAkB;iBAqGjC,8BAA8B;EAC3C;EACA;;iBAEa,4BAA4B,UAAUC,YAAiBA,mBAAwB,mBAAmB;EAC/G,KAAK;EACL,MAAMC,gBAAuB;;iBAEhB,mBAAmB,UAAUD,YAAiBA,mBAAwB,UAAU;EAC7F,MAAM,4BAA4B;;qBAEjB,oBAAoBD,aAAkB;iBAC1C,8BAA8B;EAC3C;EACA;;iBAEa,4BAA4B,UAAUC,YAAiBA,mBAAwB,mBAAmB;EAC/G,KAAK;EACL,MAAME,kBAAyB;;iBAElB,mBAAmB,UAAUF,YAAiBA,mBAAwB,UAAU;EAC7F,MAAM,4BAA4B;;qBAEjB,oBAAoBD,aAAkB;iBAC1C,iCAAiC;EAC9C;EACA;;iBAEa,+BAA+B,UAAUC,YAAiBA,mBAAwB,mBAAmB;EAClH,KAAK;EACL,MAAMC,gBAAuB,KAAKC,kBAAyB;;iBAE9C,sBAAsB,UAAUF,YAAiBA,mBAAwB,UAAU;EAChG,MAAM,+BAA+B;;qBAEpB,uBAAuBD,aAAkB;YAClD"}

package/dist/node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/core/core.d.mts

@@ -0,0 +1,50 @@
+import { Class, ProtoOf } from "./util.mjs";
+import { SomeType } from "./schemas.mjs";
+//#region ../../../node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/core/core.d.cts
+type ZodTrait = {
+  _zod: {
+    def: any;
+    [k: string]: any;
+  };
+};
+export interface $constructor<T extends ZodTrait, D = T["_zod"]["def"]> {
+  new (def: D): T;
+  init(inst: T, def: D): asserts inst is T;
+}
+export interface $constructorParams {
+  Parent?: typeof Class;
+}
+export declare function $constructor<T extends ZodTrait, D = T["_zod"]["def"]>(name: string, initializer: (inst: T, def: D) => void,
+/** This trait's members, installed once on every prototype that composes it. They cannot be declared in the initializer above: that runs per instance, and the prototype is shared. */
+proto?: ProtoOf<T>, params?: $constructorParams): $constructor<T, D>;
+export declare const $brand: unique symbol;
+export type $brand<T extends string | number | symbol = string | number | symbol> = {
+  [$brand]: { [k in T]: true; };
+};
+export type $ZodBranded<T extends SomeType, Brand extends string | number | symbol, Dir extends "in" | "out" | "inout" = "out"> = T & (Dir extends "inout" ? {
+  _zod: {
+    input: input<T> & $brand<Brand>;
+    output: output<T> & $brand<Brand>;
+  };
+} : Dir extends "in" ? {
+  _zod: {
+    input: input<T> & $brand<Brand>;
+  };
+} : {
+  _zod: {
+    output: output<T> & $brand<Brand>;
+  };
+});
+export type input<T> = T extends {
+  _zod: {
+    input: any;
+  };
+} ? T["_zod"]["input"] : unknown;
+export type output<T> = T extends {
+  _zod: {
+    output: any;
+  };
+} ? T["_zod"]["output"] : unknown;
+//#endregion
+export type { output as infer };
+//# sourceMappingURL=core.d.mts.map

package/dist/node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/core/core.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.mts","names":["schemas.SomeType"],"sources":["../../../../../../../../../../../node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/core/core.d.cts"],"ignoreList":[0],"mappings":";;;KAGK;EACD;IACI;KACC;;;iBAGQ,aAAa,UAAU,UAAU,IAAI;OAC7C,KAAK,IAAI;EACd,KAAK,MAAM,GAAG,KAAK,YAAY,QAAQ;;iBAE1B;EACb,gBAAgB;;wBAII,aAAa,UAAU,UAAU,IAAI,kBAAkB,cAAc,cAAc,MAAM,GAAG,KAAK;;AAEzH,QAAQ,QAAQ,IAAI,SAAS,qBAAqB,aAAa,GAAG;qBAC7C;YACT,OAAO;GACd,YACI,KAAK;;YAGF,YAAY,UAAUA,UAAkB,wCAAwC,8CAA8C,KAAK;EAC3I;IACI,OAAO,MAAM,KAAK,OAAO;IACzB,QAAQ,OAAO,KAAK,OAAO;;IAE/B;EACA;IACI,OAAO,MAAM,KAAK,OAAO;;;EAG7B;IACI,QAAQ,OAAO,KAAK,OAAO;;;YAcvB,MAAM,KAAK;EACnB;IACI;;IAEJ;YACQ,OAAO,KAAK;EACpB;IACI;;IAEJ"}