@arkenv/standard 1.0.0-alpha.4 → 1.0.0-alpha.5

package/dist/index.d.cts

@@ -830,11 +830,11 @@ declare const ExactLength$1: {
 //#region ../../node_modules/.pnpm/@ark+schema@0.56.0/node_modules/@ark/schema/out/shared/standardSchema.d.ts
 /** From https://github.com/standard-schema/standard-schema */
 /** The Standard Typed interface. This is a base type extended by other specs. */
-interface StandardTypedV1$2<Input = unknown, Output = Input> {
+interface StandardTypedV1$3<Input = unknown, Output = Input> {
   /** The Standard properties. */
-  readonly "~standard": StandardTypedV1$2.Props<Input, Output>;
+  readonly "~standard": StandardTypedV1$3.Props<Input, Output>;
 }
-declare namespace StandardTypedV1$2 {
+declare namespace StandardTypedV1$3 {
   /** The Standard Typed properties interface. */
   interface Props<Input = unknown, Output = Input> {
     /** The version number of the standard. */
@@ -852,20 +852,20 @@ declare namespace StandardTypedV1$2 {
     readonly output: Output;
   }
   /** Infers the input type of a Standard Typed. */
-  type InferInput<Schema extends StandardTypedV1$2> = NonNullable<Schema["~standard"]["types"]>["input"];
+  type InferInput<Schema extends StandardTypedV1$3> = NonNullable<Schema["~standard"]["types"]>["input"];
   /** Infers the output type of a Standard Typed. */
-  type InferOutput<Schema extends StandardTypedV1$2> = NonNullable<Schema["~standard"]["types"]>["output"];
+  type InferOutput<Schema extends StandardTypedV1$3> = NonNullable<Schema["~standard"]["types"]>["output"];
 }
 /** The Standard Schema interface. */
-interface StandardSchemaV1$2<Input = unknown, Output = Input> {
+interface StandardSchemaV1$3<Input = unknown, Output = Input> {
   /** The Standard Schema properties. */
-  readonly "~standard": StandardSchemaV1$2.Props<Input, Output>;
+  readonly "~standard": StandardSchemaV1$3.Props<Input, Output>;
 }
-declare namespace StandardSchemaV1$2 {
+declare namespace StandardSchemaV1$3 {
   /** The Standard Schema properties interface. */
-  interface Props<Input = unknown, Output = Input> extends StandardTypedV1$2.Props<Input, Output> {
+  interface Props<Input = unknown, Output = Input> extends StandardTypedV1$3.Props<Input, Output> {
     /** Validates unknown input values. */
-    readonly validate: (value: unknown, options?: StandardSchemaV1$2.Options | undefined) => Result<Output> | Promise<Result<Output>>;
+    readonly validate: (value: unknown, options?: StandardSchemaV1$3.Options | undefined) => Result<Output> | Promise<Result<Output>>;
   }
   /** The result interface of the validate function. */
   type Result<Output> = SuccessResult<Output> | FailureResult;
@@ -898,11 +898,11 @@ declare namespace StandardSchemaV1$2 {
     readonly key: PropertyKey;
   }
   /** The Standard types interface. */
-  interface Types<Input = unknown, Output = Input> extends StandardTypedV1$2.Types<Input, Output> {}
+  interface Types<Input = unknown, Output = Input> extends StandardTypedV1$3.Types<Input, Output> {}
   /** Infers the input type of a Standard. */
-  type InferInput<Schema extends StandardTypedV1$2> = StandardTypedV1$2.InferInput<Schema>;
+  type InferInput<Schema extends StandardTypedV1$3> = StandardTypedV1$3.InferInput<Schema>;
   /** Infers the output type of a Standard. */
-  type InferOutput<Schema extends StandardTypedV1$2> = StandardTypedV1$2.InferOutput<Schema>;
+  type InferOutput<Schema extends StandardTypedV1$3> = StandardTypedV1$3.InferOutput<Schema>;
   /** ArkType-specific properties that extend the standard schema with JSON Schema support. */
   interface ArkTypeProps<Input = unknown, Output = Input> extends Props<Input, Output>, StandardJSONSchemaV1$1.Props<Input, Output> {
     vendor: "arktype";
@@ -915,7 +915,7 @@ interface StandardJSONSchemaV1$1<Input = unknown, Output = Input> {
 }
 declare namespace StandardJSONSchemaV1$1 {
   /** The Standard JSON Schema properties interface. */
-  interface Props<Input = unknown, Output = Input> extends StandardTypedV1$2.Props<Input, Output> {
+  interface Props<Input = unknown, Output = Input> extends StandardTypedV1$3.Props<Input, Output> {
     /** Methods for generating the input/output JSON Schema. */
     readonly jsonSchema: StandardJSONSchemaV1$1.Converter;
   }
@@ -942,11 +942,11 @@ declare namespace StandardJSONSchemaV1$1 {
     readonly libraryOptions?: Record<string, unknown> | undefined;
   }
   /** The Standard types interface. */
-  interface Types<Input = unknown, Output = Input> extends StandardTypedV1$2.Types<Input, Output> {}
+  interface Types<Input = unknown, Output = Input> extends StandardTypedV1$3.Types<Input, Output> {}
   /** Infers the input type of a Standard. */
-  type InferInput<Schema extends StandardTypedV1$2> = StandardTypedV1$2.InferInput<Schema>;
+  type InferInput<Schema extends StandardTypedV1$3> = StandardTypedV1$3.InferInput<Schema>;
   /** Infers the output type of a Standard. */
-  type InferOutput<Schema extends StandardTypedV1$2> = StandardTypedV1$2.InferOutput<Schema>;
+  type InferOutput<Schema extends StandardTypedV1$3> = StandardTypedV1$3.InferOutput<Schema>;
 }
 //#endregion
 //#region ../../node_modules/.pnpm/@ark+schema@0.56.0/node_modules/@ark/schema/out/shared/toJsonSchema.d.ts
@@ -1164,7 +1164,7 @@ declare namespace ArkErrors$1 {
  * Subsequent errors added at an existing path are merged into an
  * ArkError intersection.
  */
-declare class ArkErrors$1 extends ReadonlyArray$2<ArkError$1> implements StandardSchemaV1$2.FailureResult {
+declare class ArkErrors$1 extends ReadonlyArray$2<ArkError$1> implements StandardSchemaV1$3.FailureResult {
   readonly [arkKind$1] = "errors";
   protected ctx: Traversal$1;
   constructor(ctx: Traversal$1);
@@ -2002,14 +2002,14 @@ type DiscriminantKind$1 = show$1<keyof DiscriminantKinds$1>;
 interface InternalRootDeclaration$1 extends BaseNodeDeclaration$1 {
   kind: RootKind$1;
 }
-declare abstract class BaseRoot$1< /** @ts-ignore cast variance */out d extends InternalRootDeclaration$1 = InternalRootDeclaration$1> extends BaseNode$1<d> implements StandardSchemaV1$2, StandardJSONSchemaV1$1 {
+declare abstract class BaseRoot$1< /** @ts-ignore cast variance */out d extends InternalRootDeclaration$1 = InternalRootDeclaration$1> extends BaseNode$1<d> implements StandardSchemaV1$3, StandardJSONSchemaV1$1 {
   readonly [arkKind$1]: "root";
   readonly [inferred$1]: unknown;
   constructor(attachments: UnknownAttachments$1, $: BaseScope$1);
   get rawIn(): BaseRoot$1;
   get rawOut(): BaseRoot$1;
   get internal(): this;
-  get "~standard"(): StandardSchemaV1$2.ArkTypeProps;
+  get "~standard"(): StandardSchemaV1$3.ArkTypeProps;
   as(): this;
   brand(name: string): this;
   readonly(): this;
@@ -4859,7 +4859,7 @@ interface Type$8<out t = unknown, $ = {}> extends Callable$1<(data: unknown) =>
    */
   distribute<mapOut, reduceOut = mapOut[]>(mapBranch: (branch: Type$8, i: number, branches: array$1<Type$8>) => mapOut, reduceMapped?: (mappedBranches: mapOut[]) => reduceOut): reduceOut;
   /** The Type's [StandardSchema](https://github.com/standard-schema/standard-schema) properties */
-  "~standard": StandardSchemaV1$2.ArkTypeProps<this["inferIn"] extends infer _ ? _ : never, this["inferOut"] extends infer _ ? _ : never>;
+  "~standard": StandardSchemaV1$3.ArkTypeProps<this["inferIn"] extends infer _ ? _ : never, this["inferOut"] extends infer _ ? _ : never>;
   /** @deprecated */
   apply: Function["apply"];
   /** @deprecated */
@@ -5330,13 +5330,13 @@ type parseGenericScopeKey$1<name extends string, params extends string, def> = {
 type InnerParseResult$1 = BaseRoot$1 | ParsedOptionalProperty$1 | ParsedDefaultableProperty$1;
 //#endregion
 //#region ../../node_modules/.pnpm/arktype@2.2.0/node_modules/arktype/out/parser/definition.d.ts
-type inferDefinition$1<def, $, args> = [def] extends [anyOrNever$1] ? def : def extends type$1.cast<infer t> ? ifEmptyObjectLiteral$1<def, object, t> : def extends ThunkCast$1<infer t> ? t : def extends string ? inferString$1<def, $, args> : def extends array$1 ? inferTuple$1<def, $, args> : def extends RegExp ? string : def extends StandardSchemaV1$2 ? inferStandardSchema$1<def> : def extends object ? inferObjectLiteral$1<def, $, args> : never;
-type inferStandardSchema$1<schema extends StandardSchemaV1$2, i = StandardSchemaV1$2.InferInput<schema>, o = StandardSchemaV1$2.InferOutput<schema>> = [i, o] extends [o, i] ? i : (In: i) => Out$1<o>;
+type inferDefinition$1<def, $, args> = [def] extends [anyOrNever$1] ? def : def extends type$1.cast<infer t> ? ifEmptyObjectLiteral$1<def, object, t> : def extends ThunkCast$1<infer t> ? t : def extends string ? inferString$1<def, $, args> : def extends array$1 ? inferTuple$1<def, $, args> : def extends RegExp ? string : def extends StandardSchemaV1$3 ? inferStandardSchema$1<def> : def extends object ? inferObjectLiteral$1<def, $, args> : never;
+type inferStandardSchema$1<schema extends StandardSchemaV1$3, i = StandardSchemaV1$3.InferInput<schema>, o = StandardSchemaV1$3.InferOutput<schema>> = [i, o] extends [o, i] ? i : (In: i) => Out$1<o>;
 type validateDefinition$1<def, $, args> = null extends undefined ? ErrorMessage$1<`'strict' or 'strictNullChecks' must be set to true in your tsconfig's 'compilerOptions'`> : [def] extends [anyOrNever$1] ? def : def extends OptionalPropertyDefinition$1 ? ErrorMessage$1<shallowOptionalMessage$1> : isDefaultable$1<def, $, args> extends true ? ErrorMessage$1<shallowDefaultableMessage$1> : validateInnerDefinition$1<def, $, args>;
 type validateInnerDefinition$1<def, $, args> = [def] extends [TerminalObjectDefinition$1] ? def : def extends string ? validateString$1<def, $, args> : unknown extends def ? BaseCompletions$1<$, args> | {} : def extends readonly unknown[] ? validateTuple$1<def, $, args> : def extends BadDefinitionType$1 ? ErrorMessage$1<writeBadDefinitionTypeMessage$1<objectKindOrDomainOf$1<def>>> : validateObjectLiteral$1<def, $, args>;
 type validateTuple$1<def extends array$1, $, args> = maybeValidateTupleExpression$1<def, $, args> extends infer result ? result extends null ? validateTupleLiteral$1<def, $, args> : result : never;
 type inferTuple$1<def extends array$1, $, args> = def extends TupleExpression$1 ? inferTupleExpression$1<def, $, args> : inferTupleLiteral$1<def, $, args>;
-type TerminalObjectDefinition$1 = type$1.cast<unknown> | Fn$1 | RegExp | StandardSchemaV1$2;
+type TerminalObjectDefinition$1 = type$1.cast<unknown> | Fn$1 | RegExp | StandardSchemaV1$3;
 type ThunkCast$1<t = unknown> = () => type$1.cast<t>;
 type BadDefinitionType$1 = Exclude<Primitive$1, string>;
 declare const writeBadDefinitionTypeMessage$1: <actual extends string>(actual: actual) => writeBadDefinitionTypeMessage$1<actual>;
@@ -6064,80 +6064,140 @@ l & r : r extends array$1 ? l & r : keyof l & keyof r extends never ? show$1<l &
  * Copied from standard-schema (MIT License)
  * Copyright (c) 2024 Colin McDannell
  */
-/** The Standard Typed interface. This is a base type extended by other specs. */
-interface StandardTypedV1$1<Input = unknown, Output = Input> {
-  /** The Standard properties. */
-  readonly "~standard": StandardTypedV1$1.Props<Input, Output>;
+/**
+ * The Standard Typed interface. This is a base type extended by other specs.
+ */
+interface StandardTypedV1$2<Input = unknown, Output = Input> {
+  /**
+   * The Standard properties.
+   */
+  readonly "~standard": StandardTypedV1$2.Props<Input, Output>;
 }
-declare namespace StandardTypedV1$1 {
-  /** The Standard Typed properties interface. */
+declare namespace StandardTypedV1$2 {
+  /**
+   * The Standard Typed properties interface.
+   */
   interface Props<Input = unknown, Output = Input> {
-    /** The version number of the standard. */
+    /**
+     * The version number of the standard.
+     */
     readonly version: 1;
-    /** The vendor name of the schema library. */
+    /**
+     * The vendor name of the schema library.
+     */
     readonly vendor: string;
-    /** Inferred types associated with the schema. */
+    /**
+     * Inferred types associated with the schema.
+     */
     readonly types?: Types<Input, Output> | undefined;
   }
-  /** The Standard Typed types interface. */
+  /**
+   * The Standard Typed types interface.
+   */
   interface Types<Input = unknown, Output = Input> {
-    /** The input type of the schema. */
+    /**
+     * The input type of the schema.
+     */
     readonly input: Input;
-    /** The output type of the schema. */
+    /**
+     * The output type of the schema.
+     */
     readonly output: Output;
   }
-  /** Infers the input type of a Standard Typed. */
-  type InferInput<Schema extends StandardTypedV1$1> = NonNullable<Schema["~standard"]["types"]>["input"];
-  /** Infers the output type of a Standard Typed. */
-  type InferOutput<Schema extends StandardTypedV1$1> = NonNullable<Schema["~standard"]["types"]>["output"];
+  /**
+   * Infers the input type of a Standard Typed.
+   */
+  type InferInput<Schema extends StandardTypedV1$2> = NonNullable<Schema["~standard"]["types"]>["input"];
+  /**
+   * Infers the output type of a Standard Typed.
+   */
+  type InferOutput<Schema extends StandardTypedV1$2> = NonNullable<Schema["~standard"]["types"]>["output"];
 }
-/** The Standard Schema interface. */
-interface StandardSchemaV1$1<Input = unknown, Output = Input> {
-  /** The Standard Schema properties. */
-  readonly "~standard": StandardSchemaV1$1.Props<Input, Output>;
+/**
+ * The Standard Schema interface.
+ */
+interface StandardSchemaV1$2<Input = unknown, Output = Input> {
+  /**
+   * The Standard Schema properties.
+   */
+  readonly "~standard": StandardSchemaV1$2.Props<Input, Output>;
 }
-declare namespace StandardSchemaV1$1 {
-  /** The Standard Schema properties interface. */
-  interface Props<Input = unknown, Output = Input> extends StandardTypedV1$1.Props<Input, Output> {
-    /** Validates unknown input values. */
-    readonly validate: (value: unknown, options?: StandardSchemaV1$1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
+declare namespace StandardSchemaV1$2 {
+  /**
+   * The Standard Schema properties interface.
+   */
+  interface Props<Input = unknown, Output = Input> extends StandardTypedV1$2.Props<Input, Output> {
+    /**
+     * Validates unknown input values.
+     */
+    readonly validate: (value: unknown, options?: StandardSchemaV1$2.Options | undefined) => Result<Output> | Promise<Result<Output>>;
   }
-  /** The result interface of the validate function. */
+  /**
+   * The result interface of the validate function.
+   */
   type Result<Output> = SuccessResult<Output> | FailureResult;
-  /** The result interface if validation succeeds. */
+  /**
+   * The result interface if validation succeeds.
+   */
   interface SuccessResult<Output> {
-    /** The typed output value. */
+    /**
+     * The typed output value.
+     */
     readonly value: Output;
-    /** A falsy value for `issues` indicates success. */
+    /**
+     * A falsy value for `issues` indicates success.
+     */
     readonly issues?: undefined;
   }
   interface Options {
-    /** Explicit support for additional vendor-specific parameters, if needed. */
+    /**
+     * Explicit support for additional vendor-specific parameters, if needed.
+     */
     readonly libraryOptions?: Record<string, unknown> | undefined;
   }
-  /** The result interface if validation fails. */
+  /**
+   * The result interface if validation fails.
+   */
   interface FailureResult {
-    /** The issues of failed validation. */
+    /**
+     * The issues of failed validation.
+     */
     readonly issues: ReadonlyArray<Issue>;
   }
-  /** The issue interface of the failure output. */
+  /**
+   * The issue interface of the failure output.
+   */
   interface Issue {
-    /** The error message of the issue. */
+    /**
+     * The error message of the issue.
+     */
     readonly message: string;
-    /** The path of the issue, if any. */
+    /**
+     * The path of the issue, if any.
+     */
     readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
   }
-  /** The path segment interface of the issue. */
+  /**
+   * The path segment interface of the issue.
+   */
   interface PathSegment {
-    /** The key representing a path segment. */
+    /**
+     * The key representing a path segment.
+     */
     readonly key: PropertyKey;
   }
-  /** The Standard types interface. */
-  interface Types<Input = unknown, Output = Input> extends StandardTypedV1$1.Types<Input, Output> {}
-  /** Infers the input type of a Standard. */
-  type InferInput<Schema extends StandardTypedV1$1> = StandardTypedV1$1.InferInput<Schema>;
-  /** Infers the output type of a Standard. */
-  type InferOutput<Schema extends StandardTypedV1$1> = StandardTypedV1$1.InferOutput<Schema>;
+  /**
+   * The Standard types interface.
+   */
+  interface Types<Input = unknown, Output = Input> extends StandardTypedV1$2.Types<Input, Output> {}
+  /**
+   * Infers the input type of a Standard.
+   */
+  type InferInput<Schema extends StandardTypedV1$2> = StandardTypedV1$2.InferInput<Schema>;
+  /**
+   * Infers the output type of a Standard.
+   */
+  type InferOutput<Schema extends StandardTypedV1$2> = StandardTypedV1$2.InferOutput<Schema>;
 }
 //#endregion
 //#region ../internal/utils/dist/index.d.ts
@@ -6948,11 +7008,11 @@ declare const ExactLength: {
 //#region ../../../node_modules/.pnpm/@ark+schema@0.56.0/node_modules/@ark/schema/out/shared/standardSchema.d.ts
 /** From https://github.com/standard-schema/standard-schema */
 /** The Standard Typed interface. This is a base type extended by other specs. */
-interface StandardTypedV1<Input = unknown, Output = Input> {
+interface StandardTypedV1$1<Input = unknown, Output = Input> {
   /** The Standard properties. */
-  readonly "~standard": StandardTypedV1.Props<Input, Output>;
+  readonly "~standard": StandardTypedV1$1.Props<Input, Output>;
 }
-declare namespace StandardTypedV1 {
+declare namespace StandardTypedV1$1 {
   /** The Standard Typed properties interface. */
   interface Props<Input = unknown, Output = Input> {
     /** The version number of the standard. */
@@ -6970,20 +7030,20 @@ declare namespace StandardTypedV1 {
     readonly output: Output;
   }
   /** Infers the input type of a Standard Typed. */
-  type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+  type InferInput<Schema extends StandardTypedV1$1> = NonNullable<Schema["~standard"]["types"]>["input"];
   /** Infers the output type of a Standard Typed. */
-  type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+  type InferOutput<Schema extends StandardTypedV1$1> = NonNullable<Schema["~standard"]["types"]>["output"];
 }
 /** The Standard Schema interface. */
-interface StandardSchemaV1<Input = unknown, Output = Input> {
+interface StandardSchemaV1$1<Input = unknown, Output = Input> {
   /** The Standard Schema properties. */
-  readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+  readonly "~standard": StandardSchemaV1$1.Props<Input, Output>;
 }
-declare namespace StandardSchemaV1 {
+declare namespace StandardSchemaV1$1 {
   /** The Standard Schema properties interface. */
-  interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+  interface Props<Input = unknown, Output = Input> extends StandardTypedV1$1.Props<Input, Output> {
     /** Validates unknown input values. */
-    readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
+    readonly validate: (value: unknown, options?: StandardSchemaV1$1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
   }
   /** The result interface of the validate function. */
   type Result<Output> = SuccessResult<Output> | FailureResult;
@@ -7016,11 +7076,11 @@ declare namespace StandardSchemaV1 {
     readonly key: PropertyKey;
   }
   /** The Standard types interface. */
-  interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
+  interface Types<Input = unknown, Output = Input> extends StandardTypedV1$1.Types<Input, Output> {}
   /** Infers the input type of a Standard. */
-  type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+  type InferInput<Schema extends StandardTypedV1$1> = StandardTypedV1$1.InferInput<Schema>;
   /** Infers the output type of a Standard. */
-  type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+  type InferOutput<Schema extends StandardTypedV1$1> = StandardTypedV1$1.InferOutput<Schema>;
   /** ArkType-specific properties that extend the standard schema with JSON Schema support. */
   interface ArkTypeProps<Input = unknown, Output = Input> extends Props<Input, Output>, StandardJSONSchemaV1.Props<Input, Output> {
     vendor: "arktype";
@@ -7033,7 +7093,7 @@ interface StandardJSONSchemaV1<Input = unknown, Output = Input> {
 }
 declare namespace StandardJSONSchemaV1 {
   /** The Standard JSON Schema properties interface. */
-  interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+  interface Props<Input = unknown, Output = Input> extends StandardTypedV1$1.Props<Input, Output> {
     /** Methods for generating the input/output JSON Schema. */
     readonly jsonSchema: StandardJSONSchemaV1.Converter;
   }
@@ -7060,11 +7120,11 @@ declare namespace StandardJSONSchemaV1 {
     readonly libraryOptions?: Record<string, unknown> | undefined;
   }
   /** The Standard types interface. */
-  interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
+  interface Types<Input = unknown, Output = Input> extends StandardTypedV1$1.Types<Input, Output> {}
   /** Infers the input type of a Standard. */
-  type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+  type InferInput<Schema extends StandardTypedV1$1> = StandardTypedV1$1.InferInput<Schema>;
   /** Infers the output type of a Standard. */
-  type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+  type InferOutput<Schema extends StandardTypedV1$1> = StandardTypedV1$1.InferOutput<Schema>;
 } //#endregion
 //#region ../../../node_modules/.pnpm/@ark+schema@0.56.0/node_modules/@ark/schema/out/shared/toJsonSchema.d.ts
 declare class ToJsonSchemaError<code extends ToJsonSchema.Code = ToJsonSchema.Code> extends Error {
@@ -7278,7 +7338,7 @@ declare namespace ArkErrors {
  * Subsequent errors added at an existing path are merged into an
  * ArkError intersection.
  */
-declare class ArkErrors extends ReadonlyArray$1<ArkError> implements StandardSchemaV1.FailureResult {
+declare class ArkErrors extends ReadonlyArray$1<ArkError> implements StandardSchemaV1$1.FailureResult {
   readonly [arkKind] = "errors";
   protected ctx: Traversal;
   constructor(ctx: Traversal);
@@ -8098,14 +8158,14 @@ type DiscriminantKind = show<keyof DiscriminantKinds>; //#endregion
 interface InternalRootDeclaration extends BaseNodeDeclaration {
   kind: RootKind;
 }
-declare abstract class BaseRoot< /** @ts-ignore cast variance */out d extends InternalRootDeclaration = InternalRootDeclaration> extends BaseNode<d> implements StandardSchemaV1, StandardJSONSchemaV1 {
+declare abstract class BaseRoot< /** @ts-ignore cast variance */out d extends InternalRootDeclaration = InternalRootDeclaration> extends BaseNode<d> implements StandardSchemaV1$1, StandardJSONSchemaV1 {
   readonly [arkKind]: "root";
   readonly [inferred]: unknown;
   constructor(attachments: UnknownAttachments, $: BaseScope);
   get rawIn(): BaseRoot;
   get rawOut(): BaseRoot;
   get internal(): this;
-  get "~standard"(): StandardSchemaV1.ArkTypeProps;
+  get "~standard"(): StandardSchemaV1$1.ArkTypeProps;
   as(): this;
   brand(name: string): this;
   readonly(): this;
@@ -10894,7 +10954,7 @@ interface Type$1<out t = unknown, $ = {}> extends Callable<(data: unknown) => di
    */
   distribute<mapOut, reduceOut = mapOut[]>(mapBranch: (branch: Type$1, i: number, branches: array<Type$1>) => mapOut, reduceMapped?: (mappedBranches: mapOut[]) => reduceOut): reduceOut;
   /** The Type's [StandardSchema](https://github.com/standard-schema/standard-schema) properties */
-  "~standard": StandardSchemaV1.ArkTypeProps<this["inferIn"] extends infer _ ? _ : never, this["inferOut"] extends infer _ ? _ : never>;
+  "~standard": StandardSchemaV1$1.ArkTypeProps<this["inferIn"] extends infer _ ? _ : never, this["inferOut"] extends infer _ ? _ : never>;
   /** @deprecated */
   apply: Function["apply"];
   /** @deprecated */
@@ -11359,13 +11419,13 @@ type parseGenericScopeKey<name extends string, params extends string, def> = {
 };
 type InnerParseResult = BaseRoot | ParsedOptionalProperty | ParsedDefaultableProperty; //#endregion
 //#region ../../../node_modules/.pnpm/arktype@2.2.0/node_modules/arktype/out/parser/definition.d.ts
-type inferDefinition<def, $, args> = [def] extends [anyOrNever] ? def : def extends type.cast<infer t> ? ifEmptyObjectLiteral<def, object, t> : def extends ThunkCast<infer t> ? t : def extends string ? inferString<def, $, args> : def extends array ? inferTuple<def, $, args> : def extends RegExp ? string : def extends StandardSchemaV1 ? inferStandardSchema<def> : def extends object ? inferObjectLiteral<def, $, args> : never;
-type inferStandardSchema<schema extends StandardSchemaV1, i = StandardSchemaV1.InferInput<schema>, o = StandardSchemaV1.InferOutput<schema>> = [i, o] extends [o, i] ? i : (In: i) => Out<o>;
+type inferDefinition<def, $, args> = [def] extends [anyOrNever] ? def : def extends type.cast<infer t> ? ifEmptyObjectLiteral<def, object, t> : def extends ThunkCast<infer t> ? t : def extends string ? inferString<def, $, args> : def extends array ? inferTuple<def, $, args> : def extends RegExp ? string : def extends StandardSchemaV1$1 ? inferStandardSchema<def> : def extends object ? inferObjectLiteral<def, $, args> : never;
+type inferStandardSchema<schema extends StandardSchemaV1$1, i = StandardSchemaV1$1.InferInput<schema>, o = StandardSchemaV1$1.InferOutput<schema>> = [i, o] extends [o, i] ? i : (In: i) => Out<o>;
 type validateDefinition<def, $, args> = null extends undefined ? ErrorMessage<`'strict' or 'strictNullChecks' must be set to true in your tsconfig's 'compilerOptions'`> : [def] extends [anyOrNever] ? def : def extends OptionalPropertyDefinition ? ErrorMessage<shallowOptionalMessage> : isDefaultable<def, $, args> extends true ? ErrorMessage<shallowDefaultableMessage> : validateInnerDefinition<def, $, args>;
 type validateInnerDefinition<def, $, args> = [def] extends [TerminalObjectDefinition] ? def : def extends string ? validateString<def, $, args> : unknown extends def ? BaseCompletions<$, args> | {} : def extends readonly unknown[] ? validateTuple<def, $, args> : def extends BadDefinitionType ? ErrorMessage<writeBadDefinitionTypeMessage<objectKindOrDomainOf<def>>> : validateObjectLiteral<def, $, args>;
 type validateTuple<def extends array, $, args> = maybeValidateTupleExpression<def, $, args> extends infer result ? result extends null ? validateTupleLiteral<def, $, args> : result : never;
 type inferTuple<def extends array, $, args> = def extends TupleExpression ? inferTupleExpression<def, $, args> : inferTupleLiteral<def, $, args>;
-type TerminalObjectDefinition = type.cast<unknown> | Fn | RegExp | StandardSchemaV1;
+type TerminalObjectDefinition = type.cast<unknown> | Fn | RegExp | StandardSchemaV1$1;
 type ThunkCast<t = unknown> = () => type.cast<t>;
 type BadDefinitionType = Exclude<Primitive, string>;
 declare const writeBadDefinitionTypeMessage: <actual extends string>(actual: actual) => writeBadDefinitionTypeMessage<actual>;
@@ -12072,6 +12132,148 @@ interface MorphableIntersection<piped extends boolean> extends Hkt<[unknown, unk
 }
 type intersectObjects<l, r, piped extends boolean> = l extends array ? r extends array ? intersectArrays<l, r, MorphableIntersection<piped>> : // for an intersection with exactly one array operand like { name: string } & string[],
 l & r : r extends array ? l & r : keyof l & keyof r extends never ? show<l & r> : show<{ [k in keyof l]: k extends keyof r ? _inferIntersection<l[k], r[k], piped> : l[k] } & { [k in keyof r]: k extends keyof l ? _inferIntersection<l[k], r[k], piped> : r[k] }>; //#endregion
+//#region ../types/dist/standard-schema.d.ts
+/**
+ * @see https://github.com/standard-schema/standard-schema/tree/3130ce43fdd848d9ab49dbb0458d04f18459961c/packages/spec
+ *
+ * Copied from standard-schema (MIT License)
+ * Copyright (c) 2024 Colin McDannell
+ */
+/**
+ * The Standard Typed interface. This is a base type extended by other specs.
+ */
+interface StandardTypedV1<Input = unknown, Output = Input> {
+  /**
+   * The Standard properties.
+   */
+  readonly "~standard": StandardTypedV1.Props<Input, Output>;
+}
+declare namespace StandardTypedV1 {
+  /**
+   * The Standard Typed properties interface.
+   */
+  interface Props<Input = unknown, Output = Input> {
+    /**
+     * The version number of the standard.
+     */
+    readonly version: 1;
+    /**
+     * The vendor name of the schema library.
+     */
+    readonly vendor: string;
+    /**
+     * Inferred types associated with the schema.
+     */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  /**
+   * The Standard Typed types interface.
+   */
+  interface Types<Input = unknown, Output = Input> {
+    /**
+     * The input type of the schema.
+     */
+    readonly input: Input;
+    /**
+     * The output type of the schema.
+     */
+    readonly output: Output;
+  }
+  /**
+   * Infers the input type of a Standard Typed.
+   */
+  type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+  /**
+   * Infers the output type of a Standard Typed.
+   */
+  type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+/**
+ * The Standard Schema interface.
+ */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+  /**
+   * The Standard Schema properties.
+   */
+  readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+  /**
+   * The Standard Schema properties interface.
+   */
+  interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+    /**
+     * Validates unknown input values.
+     */
+    readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
+  }
+  /**
+   * The result interface of the validate function.
+   */
+  type Result<Output> = SuccessResult<Output> | FailureResult;
+  /**
+   * The result interface if validation succeeds.
+   */
+  interface SuccessResult<Output> {
+    /**
+     * The typed output value.
+     */
+    readonly value: Output;
+    /**
+     * A falsy value for `issues` indicates success.
+     */
+    readonly issues?: undefined;
+  }
+  interface Options {
+    /**
+     * Explicit support for additional vendor-specific parameters, if needed.
+     */
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+  }
+  /**
+   * The result interface if validation fails.
+   */
+  interface FailureResult {
+    /**
+     * The issues of failed validation.
+     */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  /**
+   * The issue interface of the failure output.
+   */
+  interface Issue {
+    /**
+     * The error message of the issue.
+     */
+    readonly message: string;
+    /**
+     * The path of the issue, if any.
+     */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+  /**
+   * The path segment interface of the issue.
+   */
+  interface PathSegment {
+    /**
+     * The key representing a path segment.
+     */
+    readonly key: PropertyKey;
+  }
+  /**
+   * The Standard types interface.
+   */
+  interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
+  /**
+   * Infers the input type of a Standard.
+   */
+  type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+  /**
+   * Infers the output type of a Standard.
+   */
+  type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+} //#endregion
 //#region src/coercion/environment.d.ts
 /**
  * Prepare an environment record by optionally stripping empty strings and applying coercion.
@@ -12087,28 +12289,96 @@ l & r : r extends array ? l & r : keyof l & keyof r extends never ? show<l & r>
 //#region src/core.d.ts
 /**
  * Machine-readable classification codes for environment validation issues.
- * Serves as the Source of Truth (SoT) for error categorization in ArkEnv.
  */
-type EnvIssueCode = /** The environment variable is required but was not provided, and has no default value. */"MISSING_VARIABLE" /** The variable value failed a type assertion (e.g., expected a number or boolean but received a string). */ | "INVALID_TYPE" /** The variable value falls below the minimum allowed numeric limit or string/array length constraint. */ | "VALUE_TOO_SMALL" /** The variable value exceeds the maximum allowed numeric limit or string/array length constraint. */ | "VALUE_TOO_LARGE" /** The variable value did not match the specified regular expression (regex) pattern constraint. */ | "PATTERN_MISMATCH" /** The variable value is not in a valid format (e.g., failed email or UUID format validation). */ | "INVALID_FORMAT" /** An undeclared key was found in the environment, and the schema config is set to reject undeclared keys. */ | "UNDECLARED_KEY" /** The provided validation schema definition itself is malformed or invalid. */ | "INVALID_SCHEMA" /** A validation error was triggered by a custom validator function or inline pipe logic. */ | "CUSTOM";
+type EnvIssueCode =
+/**
+ * The environment variable is required but was not provided, and has no default value.
+ */
+"MISSING_VARIABLE"
+/**
+ * The variable value failed a type assertion (e.g., expected a number or boolean but received a string).
+ */
+| "INVALID_TYPE"
+/**
+ * The variable value falls below the minimum allowed numeric limit or string/array length constraint.
+ */
+| "VALUE_TOO_SMALL"
+/**
+ * The variable value exceeds the maximum allowed numeric limit or string/array length constraint.
+ */
+| "VALUE_TOO_LARGE"
+/**
+ * The variable value did not match the specified regular expression (regex) pattern constraint.
+ */
+| "PATTERN_MISMATCH"
+/**
+ * The variable value is not in a valid format (e.g., failed email or UUID format validation).
+ */
+| "INVALID_FORMAT"
+/**
+ * An undeclared key was found in the environment, and the schema config is set to reject undeclared keys.
+ */
+| "UNDECLARED_KEY"
+/**
+ * The provided validation schema definition itself is malformed or invalid.
+ */
+| "INVALID_SCHEMA"
+/**
+ * A validation error was triggered by a custom validator function or inline pipe logic.
+ */
+| "CUSTOM";
 /**
  * Metadata associated with an environment validation issue.
  */
 type EnvIssueMeta = {
-  /** The minimum expected boundary for numeric/string length constraints */min?: number; /** The maximum expected boundary for numeric/string length constraints */
-  max?: number; /** Additional validation pattern/specifier details */
-  validation?: string; /** Any custom constraint descriptions */
-  constraint?: string; /** Traversal error occurred during JSON-parsing of the environment variable */
+  /**
+   * The minimum expected boundary for numeric/string length constraints
+   */
+  min?: number;
+  /**
+   * The maximum expected boundary for numeric/string length constraints
+   */
+  max?: number;
+  /**
+   * Additional validation pattern/specifier details
+   */
+  validation?: string;
+  /**
+   * Any custom constraint descriptions
+   */
+  constraint?: string;
+  /**
+   * Traversal error occurred during JSON-parsing of the environment variable
+   */
   traversalError?: string;
 };
 /**
  * Normalized validation issue representing a failure on a specific environment variable.
  */
 type EnvIssue = {
-  /** The dot-separated property path/name of the environment variable */path: string; /** The descriptive, user-friendly error message */
-  message: string; /** The normalized classification code for the issue */
-  code: EnvIssueCode; /** The expected type or value shape description */
-  expected?: string; /** The raw value received (redacted in string formatting if sensitive) */
-  received?: unknown; /** Additional validation metadata */
+  /**
+   * The dot-separated property path/name of the environment variable
+   */
+  path: string;
+  /**
+   * The descriptive, user-friendly error message
+   */
+  message: string;
+  /**
+   * The normalized classification code for the issue
+   */
+  code: EnvIssueCode;
+  /**
+   * The expected type or value shape description
+   */
+  expected?: string;
+  /**
+   * The raw value received (redacted in string formatting if sensitive)
+   */
+  received?: unknown;
+  /**
+   * Additional validation metadata
+   */
   meta?: EnvIssueMeta;
 };
 /**
@@ -12126,9 +12396,6 @@ declare function formatIssues(issues: EnvIssue[]): string;
  *
  * @example
  * ```ts
- * import arkenv from 'arkenv';
- * import { ArkEnvError } from 'arkenv/core';
- *
  * try {
  *   const env = arkenv({
  *     PORT: 'number.port',
@@ -12142,7 +12409,9 @@ declare function formatIssues(issues: EnvIssue[]): string;
  * ```
  */
 declare class ArkEnvError extends Error {
-  /** The list of normalized issues that caused the validation failure */
+  /**
+   * The list of normalized issues that caused the validation failure
+   */
   readonly issues: EnvIssue[];
   constructor(issues: EnvIssue[], message?: string);
 }
@@ -12176,10 +12445,9 @@ type ParseStandardConfig = {
   /**
    * Control how ArkEnv handles environment variables that are not defined in your schema.
    *
-   * Defaults to `'delete'` to ensure your output object only contains
-   * keys you've explicitly declared.
+   * Defaults to `'delete'` so the output object only contains keys you've declared.
    *
-   * - `delete` (ArkEnv default): Undeclared keys are allowed on input but stripped from the output.
+   * - `delete` (default): Undeclared keys are allowed on input but stripped from the output.
    * - `ignore`: Undeclared keys are allowed and preserved in the output.
    * - `reject`: Undeclared keys will cause validation to fail.
    *
@@ -12193,13 +12461,67 @@ type ParseStandardConfig = {
   debugSecrets?: boolean;
   /**
    * Whether to perform best-effort coercion on the environment variables.
-   * Coercion requires validators that implement the StandardJSONSchemaV1 spec
-   * (e.g. Zod, Valibot).
+   * Coercion prefers validators that expose Standard JSON Schema on the value
+   * itself (e.g. Zod). For converters that live outside the schema (e.g. Valibot
+   * via `@valibot/to-json-schema`, Zod Mini via `z.toJSONSchema`, or Zod v3 via
+   * `zod-to-json-schema`), pass {@link toJsonSchema}.
    *
    * @see https://standard-schema.dev
    * @default true
    */
   coerce?: boolean;
+  /**
+   * Optional fallback that converts a Standard Schema validator to JSON Schema
+   * for ArkEnv pre-coercion when a key has no Standard JSON Schema on the value.
+   *
+   * Called per key only in that case. Not called when omitted, when `coerce` is
+   * `false`, or when JSON Schema was already read from the value.
+   *
+   * - Return a plain object to use as that key's JSON Schema.
+   * - Return `undefined` to skip coercion for that key only.
+   * - Throwing or returning a non-plain object fails the parse with
+   *   {@link ArkEnvError} for that key (`INVALID_SCHEMA`).
+   *
+   * Typed as {@link StandardSchemaV1}. Host converters (Valibot, Zod Mini,
+   * Zod v3 via `zod-to-json-schema`) do not accept that type — assert at the
+   * converter call (`as v.GenericSchema`, `as z.ZodMiniType`,
+   * `as z.ZodTypeAny`). Same assertion for a single-library map and a hybrid
+   * with classic Zod (Zod never reaches this callback at runtime).
+   *
+   * @example Valibot wiring
+   * ```ts
+   * import { toJsonSchema } from "@valibot/to-json-schema";
+   * import * as v from "valibot";
+   *
+   * arkenv(
+   *   { PORT: v.number() },
+   *   {
+   *     toJsonSchema: (schema) =>
+   *       toJsonSchema(schema as v.GenericSchema, {
+   *         typeMode: "input",
+   *         target: "draft-07",
+   *       }),
+   *   },
+   * );
+   * ```
+   *
+   * @example Zod v3 wiring
+   * ```ts
+   * import { z } from "zod/v3";
+   * import { zodToJsonSchema } from "zod-to-json-schema";
+   *
+   * arkenv(
+   *   { PORT: z.number() },
+   *   {
+   *     toJsonSchema: (schema) =>
+   *       zodToJsonSchema(schema as z.ZodTypeAny, {
+   *         $refStrategy: "none",
+   *       }),
+   *   },
+   * );
+   * ```
+   */
+  toJsonSchema?: (schema: StandardSchemaV1) => object | undefined;
   /**
    * The format to use for array parsing when coercion is enabled.
    *
@@ -12239,12 +12561,11 @@ type ParseStandardConfig = {
 //#endregion
 //#region src/schema.d.ts
 /**
- * Extract the keys from a schema definition dynamically.
+ * Extract the keys from a schema definition.
  * Supports plain objects, ArkType schemas, and Standard Schema validators.
  *
  * @param schema The schema definition to extract keys from
  * @returns An array of extracted key names
- * @internal
  */
 declare function getSchemaKeys(schema: any): string[]; //#endregion
 //#region src/utils/errors.d.ts
@@ -12260,9 +12581,10 @@ declare function getSchemaKeys(schema: any): string[]; //#endregion
 //#endregion
 //#region src/index.d.ts
 /**
- * Configuration options for the `arkenv/standard` entry's `arkenv`.
+ * Configuration options for `arkenv` from `@arkenv/standard`.
  */
 type StandardEnvConfig = ParseStandardConfig;
+type StandardEnvOutput<T extends Record<string, StandardSchemaV1$2>> = { [K in keyof T]: StandardSchemaV1$2.InferOutput<T[K]> };
 /**
  * Parse and validate environment variables using Standard Schema 1.0 validators (e.g. Zod, Valibot).
  *
@@ -12285,12 +12607,9 @@ type StandardEnvConfig = ParseStandardConfig;
  * });
  * ```
  */
-declare function arkenv<const T extends Record<string, StandardSchemaV1$1>>(def: T, config?: StandardEnvConfig & {
-  safe?: false;
-}): { [K in keyof T]: StandardSchemaV1$1.InferOutput<T[K]> };
-declare function arkenv<const T extends Record<string, StandardSchemaV1$1>>(def: T, config: StandardEnvConfig & {
-  safe: true;
-}): SafeArkEnvResult<{ [K in keyof T]: StandardSchemaV1$1.InferOutput<T[K]> }>;
+declare function arkenv<const T extends Record<string, StandardSchemaV1$2>, const Safe extends boolean | undefined = undefined>(def: T, config?: Omit<StandardEnvConfig, "safe"> & {
+  safe?: Safe;
+}): [Safe] extends [true] ? SafeArkEnvResult<StandardEnvOutput<T>> : StandardEnvOutput<T>;
 //#endregion
 export { ArkEnvError, type EnvIssue, type SafeArkEnvResult, StandardEnvConfig, arkenv, arkenv as default, formatIssues, getSchemaKeys };
 //# sourceMappingURL=index.d.cts.map