@suveren/gateway 0.38.0 → 0.40.0

package/node_modules/zod/src/v4/core/standard-schema.ts

@@ -1,22 +1,51 @@
-/** The Standard Schema interface. */
-export interface StandardSchemaV1<Input = unknown, Output = Input> {
-  /** The Standard Schema properties. */
-  readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+/** The Standard interface. */
+export interface StandardTypedV1<Input = unknown, Output = Input> {
+  /** The Standard properties. */
+  readonly "~standard": StandardTypedV1.Props<Input, Output>;
 }
 
-export declare namespace StandardSchemaV1 {
-  /** The Standard Schema properties interface. */
+export declare namespace StandardTypedV1 {
+  /** The Standard properties interface. */
   export 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;
-    /** Validates unknown input values. */
-    readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
     /** Inferred types associated with the schema. */
     readonly types?: Types<Input, Output> | undefined;
   }
 
+  /** The Standard types interface. */
+  export 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. */
+  export type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+
+  /** Infers the output type of a Standard. */
+  export type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+
+/** The Standard Schema interface. */
+export interface StandardSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard Schema properties. */
+  readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+
+export declare namespace StandardSchemaV1 {
+  /** The Standard Schema properties interface. */
+  export 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. */
   export type Result<Output> = SuccessResult<Output> | FailureResult;
 
@@ -24,10 +53,15 @@ export declare namespace StandardSchemaV1 {
   export interface SuccessResult<Output> {
     /** The typed output value. */
     readonly value: Output;
-    /** The non-existent issues. */
+    /** The absence of issues indicates success. */
     readonly issues?: undefined;
   }
 
+  export interface Options {
+    /** Implicit support for additional vendor-specific parameters, if needed. */
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+  }
+
   /** The result interface if validation fails. */
   export interface FailureResult {
     /** The issues of failed validation. */
@@ -48,17 +82,78 @@ export declare namespace StandardSchemaV1 {
     readonly key: PropertyKey;
   }
 
-  /** The Standard Schema types interface. */
-  export interface Types<Input = unknown, Output = Input> {
-    /** The input type of the schema. */
-    readonly input: Input;
-    /** The output type of the schema. */
-    readonly output: Output;
+  /** The Standard types interface. */
+  export interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
+
+  /** Infers the input type of a Standard. */
+  export type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+
+  /** Infers the output type of a Standard. */
+  export type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}
+
+/** The Standard JSON Schema interface. */
+export interface StandardJSONSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard JSON Schema properties. */
+  readonly "~standard": StandardJSONSchemaV1.Props<Input, Output>;
+}
+
+export declare namespace StandardJSONSchemaV1 {
+  /** The Standard JSON Schema properties interface. */
+  export interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+    /** Methods for generating the input/output JSON Schema. */
+    readonly jsonSchema: Converter;
+  }
+
+  /** The Standard JSON Schema converter interface. */
+  export interface Converter {
+    /** Converts the input type to JSON Schema. May throw if conversion is not supported. */
+    readonly input: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
+    /** Converts the output type to JSON Schema. May throw if conversion is not supported. */
+    readonly output: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
+  }
+
+  /** The target version of the generated JSON Schema.
+   *
+   * It is *strongly recommended* that implementers support `"draft-2020-12"` and `"draft-07"`, as they are both in wide use.
+   *
+   * The `"openapi-3.0"` target is intended as a standardized specifier for OpenAPI 3.0 which is a superset of JSON Schema `"draft-04"`.
+   *
+   * All other targets can be implemented on a best-effort basis. Libraries should throw if they don't support a specified target.
+   */
+  export type Target =
+    | "draft-2020-12"
+    | "draft-07"
+    | "openapi-3.0"
+    // Accepts any string for future targets while preserving autocomplete
+    | ({} & string);
+
+  /** The options for the input/output methods. */
+  export interface Options {
+    /** Specifies the target version of the generated JSON Schema. Support for all versions is on a best-effort basis. If a given version is not supported, the library should throw. */
+    readonly target: Target;
+
+    /** Implicit support for additional vendor-specific parameters, if needed. */
+    readonly libraryOptions?: Record<string, unknown> | undefined;
   }
 
-  /** Infers the input type of a Standard Schema. */
-  export type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+  /** The Standard types interface. */
+  export interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
+
+  /** Infers the input type of a Standard. */
+  export type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+
+  /** Infers the output type of a Standard. */
+  export type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}
+
+export interface StandardSchemaWithJSONProps<Input = unknown, Output = Input>
+  extends StandardSchemaV1.Props<Input, Output>,
+    StandardJSONSchemaV1.Props<Input, Output> {}
 
-  /** Infers the output type of a Standard Schema. */
-  export type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+/**
+ * An interface that combines StandardJSONSchema and StandardSchema.
+ */
+export interface StandardSchemaWithJSON<Input = unknown, Output = Input> {
+  "~standard": StandardSchemaWithJSONProps<Input, Output>;
 }

package/node_modules/zod/src/v4/core/tests/cached.test.ts

@@ -0,0 +1,54 @@
+import { expect, test } from "vitest";
+
+import { util } from "zod/v4/core";
+
+test("cached defers the getter until the first read", () => {
+  let runs = 0;
+  const box = util.cached(() => ++runs);
+  expect(runs).toBe(0);
+  expect(box.value).toBe(1);
+  expect(box.value).toBe(1);
+  expect(runs).toBe(1);
+});
+
+test("cached memoizes an undefined result", () => {
+  let runs = 0;
+  const box = util.cached(() => {
+    runs++;
+    return undefined;
+  });
+  expect(box.value).toBeUndefined();
+  expect(box.value).toBeUndefined();
+  expect(runs).toBe(1);
+});
+
+test("cached retries after the getter throws", () => {
+  let attempts = 0;
+  const box = util.cached(() => {
+    if (++attempts < 2) throw new Error("boom");
+    return "recovered";
+  });
+  expect(() => box.value).toThrow("boom");
+  expect(box.value).toBe("recovered");
+  expect(attempts).toBe(2);
+});
+
+test("cached rejects assignment to value", () => {
+  const box = util.cached(() => 1);
+  expect(() => {
+    (box as { value: number }).value = 2;
+  }).toThrow(TypeError);
+});
+
+// the getter is inherited, so a box carries only its two state slots and stays out of dictionary mode
+test("cached keeps value on the prototype", () => {
+  const box = util.cached(() => 1);
+  expect(Object.getOwnPropertyDescriptor(box, "value")).toBeUndefined();
+  expect("value" in box).toBe(true);
+  expect(box.value).toBe(1);
+});
+
+test("allowsEval reads through the same box", () => {
+  expect(util.allowsEval.value).toBe(true);
+  expect(util.allowsEval.value).toBe(true);
+});