@kubb/plugin-faker 5.4.0-canary.20261111T122006 → 5.4.0

package/dist/index.js

@@ -1,5 +1,5 @@
+import { Diagnostics, Resolver, addGenerator, ast, casing, createPrinter, createResolver, defineExtension, defineGenerator, setMacros, setResolver, text } from "@kubb/kit";
 import { posix } from "node:path";
-import { Diagnostics, Resolver, addGenerator, ast, camelCase, containsCircularRef, createResolver, defineExtension, defineGenerator, setMacros, setResolver, syncSchemaRef } from "@kubb/kit";
 import { File, Function, jsxRenderer } from "@kubb/renderer-jsx";
 import { Fragment, jsx, jsxs } from "@kubb/renderer-jsx/jsx-runtime";
 import { buildParams, enumTypeName, pluginTsName } from "@kubb/plugin-ts";
@@ -142,67 +142,76 @@ function ensureValidVarName(name) {
 function isIdentifier(name) {
 	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
 }
-// ../../internals/utils/src/strings.ts
+// ../../internals/utils/src/codegen.ts
 /**
-* Wraps a value in single quotes for emitting a single-quoted JavaScript string literal, escaping
-* any backslash or single quote in the content.
+* Assembles a multi-line object literal from already-rendered `entries`, indenting each entry one
+* level and closing the brace at column zero. Entries that are themselves multi-line objects indent
+* cumulatively. Each entry ends with a trailing comma to match the formatter's multi-line style.
 *
 * @example
 * ```ts
-* singleQuote('foo')      // "'foo'"
-* singleQuote("o'clock")  // "'o\\'clock'"
+* buildObject(['id: z.number()', 'name: z.string()'])
+* // '{\n  id: z.number(),\n  name: z.string(),\n}'
 * ```
 */
-function singleQuote(value) {
-	if (value === void 0 || value === null) return "''";
-	return `'${String(value).replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+function buildObject(entries) {
+	if (entries.length === 0) return "{}";
+	return `{\n${entries.map((entry) => `${text.indent({ text: entry })},`).join("\n")}\n}`;
 }
 /**
-* Strips a single matching pair of `"..."`, `'...'`, or `` `...` `` from both ends of `text`.
-* Returns the string unchanged when no balanced quote pair is found.
+* An object key, quoted only when it is not identifier-shaped. Reserved words such as `class` stay bare.
 *
 * @example
 * ```ts
-* trimQuotes('"hello"') // 'hello'
-* trimQuotes('hello')   // 'hello'
+* objectKey('x-total') // "'x-total'"
 * ```
 */
-function trimQuotes(text) {
-	if (text.length >= 2) {
-		const first = text[0];
-		const last = text[text.length - 1];
-		if (first === "\"" && last === "\"" || first === "'" && last === "'" || first === "`" && last === "`") return text.slice(1, -1);
-	}
-	return text;
+function objectKey(name) {
+	return isIdentifier(name) ? name : text.quote(name);
+}
+// ../../internals/utils/src/fs.ts
+function toSlash(p) {
+	if (p.startsWith("\\\\?\\")) return p;
+	return p.replaceAll("\\", "/");
 }
 /**
-* Serializes a primitive to a single-quoted string literal, stripping any surrounding quotes first.
-*
-* Escaping runs through `JSON.stringify`, then the result switches to single quotes so the generated
-* code matches the repo style without a formatter.
+* Returns the relative path from `rootDir` to `filePath`, always using forward slashes
+* and prefixed with `./` when not already traversing upward.
 *
 * @example
 * ```ts
-* stringify('hello')   // "'hello'"
-* stringify('"hello"') // "'hello'"
+* getRelativePath('/src/components', '/src/components/Button.tsx') // './Button.tsx'
+* getRelativePath('/src/components', '/src/utils/helpers.ts')      // '../utils/helpers.ts'
 * ```
 */
-function stringify(value) {
-	if (value === void 0 || value === null) return "''";
-	return `'${JSON.stringify(trimQuotes(value.toString())).slice(1, -1).replace(/\\"/g, "\"").replace(/'/g, "\\'")}'`;
+function getRelativePath(rootDir, filePath) {
+	const relativePath = posix.relative(toSlash(rootDir), toSlash(filePath));
+	return relativePath.startsWith("../") ? relativePath : `./${relativePath}`;
 }
 /**
-* Escapes an `@` at the start of a line, so a multi-line description can't start a new JSDoc tag.
-* Editors render `\@` as `@` in hovers.
+* Builds a nested file path from a dotted name. Splits on dots that precede a letter
+* (so version numbers embedded in operationIds like `v2025.0` stay intact), camelCases
+* every earlier segment, applies `caseLast` to the final segment, and joins with `/`.
 *
-* @example
-* ```ts
-* jsDocEscape('intro\n@example value') // 'intro\n\\@example value'
-* ```
+* Empty segments are dropped before joining. They arise when the name starts with a dot
+* followed by a letter (e.g. `..Schema` splits into `['..', 'Schema']` and `'..'` cases to
+* an empty string). Without this a leading `/` would form, which `path.resolve` reads as an
+* absolute path, letting generated files escape the configured output directory.
+*
+* @example Nested path from a dotted name
+* `toFilePath('pet.petId') // 'pet/petId'`
+*
+* @example PascalCase the final segment
+* `toFilePath('pet.Pet', pascalCase) // 'pet/Pet'`
+*
+* @example Suffix applied to the final segment only
+* `toFilePath('tag.tag', (part) => camelCase(part, { suffix: 'schema' })) // 'tag/tagSchema'`
 */
-function jsDocEscape(input) {
-	return `${input}`.replace(/^(\s*)@/gm, "$1\\@");
+function toFilePath(name, caseLast = casing.camel) {
+	const parts = name.split(/\.(?=[a-zA-Z])/);
+	return parts.map((part, i) => i === parts.length - 1 ? caseLast(part) : casing.camel(part)).filter(Boolean).join("/");
 }
+// ../../internals/utils/src/strings.ts
 const NEEDS_UNICODE = /(?<!\\)(?:\\\\)*\\[pPu]\{|[\u{10000}-\u{10FFFF}]/u;
 const KEPT_ESCAPE = /[A-Za-z0-9^$\\.*+?()[\]{}|/]/;
 /**
@@ -242,8 +251,8 @@ function toRegExp(pattern, flags) {
 * toRegExpString('^(?im)foo', null) // '/^foo/im'
 * ```
 */
-function toRegExpString(text, func = "RegExp") {
-	const raw = trimQuotes(text);
+function toRegExpString(pattern, func = "RegExp") {
+	const raw = text.unquote(pattern);
 	const match = raw.match(/^\^(\(\?([igmsuy]+)\))/i);
 	const replacementTarget = match?.[1] ?? "";
 	const matchedFlags = match?.[2];
@@ -251,84 +260,17 @@ function toRegExpString(text, func = "RegExp") {
 	if (func === null) return `/${source}/${flags}`;
 	return `new ${func}(${JSON.stringify(source)}${flags ? `, ${JSON.stringify(flags)}` : ""})`;
 }
-// ../../internals/utils/src/codegen.ts
-const INDENT = "  ";
-/**
-* Indents every non-empty line of `text` by one indent level, leaving blank lines empty.
-*/
-function indentLines(text) {
-	if (!text) return "";
-	return text.split("\n").map((line) => line.trim() ? `${INDENT}${line}` : "").join("\n");
-}
-/**
-* Renders an object key, quoting it with single quotes only when it is not a valid identifier.
-* Reserved words and globals (`name`, `class`, …) are valid bare keys and stay unquoted.
-*
-* @example
-* ```ts
-* objectKey('name')    // 'name'
-* objectKey('x-total') // "'x-total'"
-* ```
-*/
-function objectKey(name) {
-	return isIdentifier(name) ? name : singleQuote(name);
-}
 /**
-* Assembles a multi-line object literal from already-rendered `entries`, indenting each entry one
-* level and closing the brace at column zero. Entries that are themselves multi-line objects indent
-* cumulatively. Each entry ends with a trailing comma to match the formatter's multi-line style.
-*
-* @example
-* ```ts
-* buildObject(['id: z.number()', 'name: z.string()'])
-* // '{\n  id: z.number(),\n  name: z.string(),\n}'
-* ```
-*/
-function buildObject(entries) {
-	if (entries.length === 0) return "{}";
-	return `{\n${entries.map((entry) => `${indentLines(entry)},`).join("\n")}\n}`;
-}
-// ../../internals/utils/src/fs.ts
-function toSlash(p) {
-	if (p.startsWith("\\\\?\\")) return p;
-	return p.replaceAll("\\", "/");
-}
-/**
-* Returns the relative path from `rootDir` to `filePath`, always using forward slashes
-* and prefixed with `./` when not already traversing upward.
+* Escapes an `@` at the start of a line, so a multi-line description can't start a new JSDoc tag.
+* Editors render `\@` as `@` in hovers.
 *
 * @example
 * ```ts
-* getRelativePath('/src/components', '/src/components/Button.tsx') // './Button.tsx'
-* getRelativePath('/src/components', '/src/utils/helpers.ts')      // '../utils/helpers.ts'
+* jsDocEscape('intro\n@example value') // 'intro\n\\@example value'
 * ```
 */
-function getRelativePath(rootDir, filePath) {
-	const relativePath = posix.relative(toSlash(rootDir), toSlash(filePath));
-	return relativePath.startsWith("../") ? relativePath : `./${relativePath}`;
-}
-/**
-* Builds a nested file path from a dotted name. Splits on dots that precede a letter
-* (so version numbers embedded in operationIds like `v2025.0` stay intact), camelCases
-* every earlier segment, applies `caseLast` to the final segment, and joins with `/`.
-*
-* Empty segments are dropped before joining. They arise when the name starts with a dot
-* followed by a letter (e.g. `..Schema` splits into `['..', 'Schema']` and `'..'` cases to
-* an empty string). Without this a leading `/` would form, which `path.resolve` reads as an
-* absolute path, letting generated files escape the configured output directory.
-*
-* @example Nested path from a dotted name
-* `toFilePath('pet.petId') // 'pet/petId'`
-*
-* @example PascalCase the final segment
-* `toFilePath('pet.Pet', pascalCase) // 'pet/Pet'`
-*
-* @example Suffix applied to the final segment only
-* `toFilePath('tag.tag', (part) => camelCase(part, { suffix: 'schema' })) // 'tag/tagSchema'`
-*/
-function toFilePath(name, caseLast = camelCase) {
-	const parts = name.split(/\.(?=[a-zA-Z])/);
-	return parts.map((part, i) => i === parts.length - 1 ? caseLast(part) : camelCase(part)).filter(Boolean).join("/");
+function jsDocEscape(input) {
+	return `${input}`.replace(/^(\s*)@/gm, "$1\\@");
 }
 // ../../internals/shared/src/operation.ts
 /**
@@ -395,19 +337,12 @@ function resolveOperationFile(options) {
 		return file;
 	});
 }
-function baseContentType(contentType) {
-	return contentType.split(";")[0].trim().toLowerCase();
-}
 /**
-* Whether a content entry is a sequence of JSON values the adapter marks as a stream, such as `application/jsonl`,
-* `application/x-ndjson`, `application/json-seq`, or any media type with an OpenAPI 3.2 `itemSchema`.
+* How a content entry is framed as a stream: `'events'` for Server-Sent Events, `'lines'` for JSON Lines.
 */
-function isJsonLines(entry) {
-	const baseType = baseContentType(entry.contentType);
-	return Boolean(entry.stream) && baseType !== "text/event-stream" && !baseType.startsWith("multipart/");
-}
-function isJsonContentType(baseType) {
-	return baseType === "application/json" || baseType.endsWith("+json") || baseType === "text/json";
+function getStreamFraming(entry) {
+	if (ast.mediaType.getBase(entry) === "text/event-stream") return "events";
+	return entry.stream && ast.mediaType.isStream(entry) ? "lines" : void 0;
 }
 /**
 * Parser for one response content entry.
@@ -418,10 +353,10 @@ function isJsonContentType(baseType) {
 * `image/*`, `audio/*`, and `video/*` are blobs.
 */
 function responseTypeForContent(entry) {
-	const baseType = baseContentType(entry.contentType);
+	const baseType = ast.mediaType.getBase(entry);
 	if (!baseType) return void 0;
-	if (baseType === "text/event-stream" || isJsonLines(entry)) return "stream";
-	if (isJsonContentType(baseType)) return void 0;
+	if (getStreamFraming(entry)) return "stream";
+	if (ast.mediaType.isJson(baseType)) return void 0;
 	if (entry.schema?.type === "blob") return "blob";
 	if (baseType.startsWith("text/")) return "text";
 	if (isBinaryContentType(baseType)) return "blob";
@@ -459,14 +394,14 @@ function getPerContentTypeName(baseName, suffix) {
 function toResponseContent(entry, entries = [entry]) {
 	const { contentType, schema } = entry;
 	if (!schema || entry.stream) return entry;
-	const baseType = baseContentType(contentType);
-	const resolved = ast.resolveRef(schema);
+	const baseType = ast.mediaType.getBase(contentType);
+	const resolved = ast.ref.getSchema(schema);
 	if (isBinaryContentType(baseType)) return resolved.type === "blob" ? entry : {
 		...entry,
 		schema: ast.factory.createSchema({ type: "blob" }),
 		keysToOmit: null
 	};
-	const isPlainMediaType = Boolean(baseType) && !isJsonContentType(baseType) && !baseType.includes("*");
+	const isPlainMediaType = Boolean(baseType) && !ast.mediaType.isJson(baseType) && !baseType.includes("*");
 	if (resolved.type === "blob") return isPlainMediaType && !entries.every((item) => item.schema?.type === "blob") ? {
 		...entry,
 		schema: ast.factory.createSchema({ type: "string" }),
@@ -509,50 +444,6 @@ function resolveContentTypeVariants(entries, baseName) {
 		};
 	});
 }
-const operationParameterGroupsByNode = /* @__PURE__ */ new WeakMap();
-/**
-* An OpenAPI 3.2 `querystring` parameter is the whole query string, so a form-encoded object becomes one query parameter
-* per property, typed and serialized like any other.
-* Another content type, such as JSON, stays one parameter named after it, and the runtime sends its value as the whole query string.
-*/
-function spreadQuerystring(param) {
-	const schema = param.schema.type === "ref" ? param.schema.schema : param.schema;
-	const formEncoded = !param.contentType || param.contentType.split(";")[0].trim().toLowerCase() === "application/x-www-form-urlencoded";
-	if (schema?.type !== "object" || !formEncoded) return [param];
-	return schema.properties.map((property) => ast.factory.createParameter({
-		name: property.name,
-		in: "query",
-		schema: property.schema,
-		required: param.required && property.required
-	}));
-}
-/**
-* Groups an operation's parameters by location (`path`/`query`/`header`/`cookie`), deduping each
-* group by name. Every plugin generator visiting the same `OperationNode` shares one AST instance
-* (see `KubbDriver`), so the result is cached per node to avoid re-filtering and re-deduping the
-* same parameters once per plugin.
-*/
-function getOperationParameters(node) {
-	const cached = operationParameterGroupsByNode.get(node);
-	if (cached) return cached;
-	const dedupe = (params) => {
-		const seen = /* @__PURE__ */ new Set();
-		return params.filter((param) => {
-			if (seen.has(param.name)) return false;
-			seen.add(param.name);
-			return true;
-		});
-	};
-	const group = (location) => dedupe(node.parameters.filter((param) => param.in === location));
-	const groups = {
-		path: group("path"),
-		query: dedupe([...group("query"), ...group("querystring").flatMap(spreadQuerystring)]),
-		header: group("header"),
-		cookie: group("cookie")
-	};
-	operationParameterGroupsByNode.set(node, groups);
-	return groups;
-}
 // ../../internals/shared/src/resolver.ts
 /**
 * Builds the allocation key for a declaration an operation owns. `scope` names which declaration
@@ -641,6 +532,13 @@ function createOperationResponseResolver() {
 				name
 			});
 		},
+		headers(node, statusCode) {
+			const name = this.name(`${node.operationId} Status ${statusCode} Headers`);
+			return this.resolveName({
+				key: operationKey(node, "response", "headers", statusCode),
+				name
+			});
+		},
 		body(node) {
 			const name = this.name(`${node.operationId} Body`);
 			return this.resolveName({
@@ -682,58 +580,7 @@ function createCasedFile(caseLast) {
 * Names of the schemas in a circular reference chain, computed once per build.
 */
 function getCircularNames(ctx) {
-	return ctx.memo("circularNames:set", () => ast.findCircularSchemas(ctx.driver.inputNode?.schemas ?? []));
-}
-// ../../internals/shared/src/group.ts
-/**
-* Builds the `group` config a Kubb plugin passes to `ctx.setOptions`, applying the
-* shared default naming so every plugin groups output consistently:
-*
-* - `path` groups use the second path segment (`/pet/findByStatus` → `pet`).
-* - other groups use the camelCased group (`pet store` → `petStore`).
-*
-* A user-provided `group.name` always wins over the default namer, so callers stay in
-* control of their output folders. Returns `null` when grouping is disabled, matching the
-* per-plugin convention.
-*
-* @param group - The user-supplied group option, or `undefined` to disable grouping.
-*
-* @example
-* ```ts
-* createGroupConfig(group) // shared across every plugin
-* ```
-*/
-function createGroupConfig(group) {
-	if (!group) return null;
-	const defaultName = (ctx) => {
-		if (group.type === "path") return `${ctx.group.split("/")[1]}`;
-		return camelCase(ctx.group);
-	};
-	return {
-		...group,
-		name: group.name ? group.name : defaultName
-	};
-}
-// ../../internals/shared/src/schemaTraversal.ts
-/**
-* Maps each member of a union or intersection schema to its transformed output, pairing every
-* result with the original member.
-*/
-function mapSchemaMembers(node, transform) {
-	return (node.members ?? []).map((schema) => ({
-		schema,
-		output: transform(schema)
-	}));
-}
-/**
-* Maps each item of an array or tuple schema to its transformed output, pairing every result with
-* the original item.
-*/
-function mapSchemaItems(node, transform) {
-	return (node.items ?? []).map((schema) => ({
-		schema,
-		output: transform(schema)
-	}));
+	return ctx.memo("circularNames:set", () => ast.graph.getCircularNames(ctx.driver.inputNode?.schemas ?? []));
 }
 // src/utils.ts
 /**
@@ -790,26 +637,29 @@ function canOverrideSchema(node) {
 * Whether a schema can supply object properties when merging faker values.
 */
 function isObjectSchema(node, seen = /* @__PURE__ */ new Set()) {
-	const resolved = ast.resolveRef(node);
+	const resolved = ast.ref.getSchema(node);
 	if (seen.has(resolved)) return false;
 	seen.add(resolved);
-	if (ast.narrowSchema(resolved, ast.schemaTypes.object) || ast.narrowSchema(resolved, ast.schemaTypes.ref)) return true;
-	const composition = ast.narrowSchema(resolved, ast.schemaTypes.intersection) ?? ast.narrowSchema(resolved, ast.schemaTypes.union);
+	if (ast.schema.narrow(resolved, ast.schema.types.object) || ast.schema.narrow(resolved, ast.schema.types.ref)) return true;
+	const composition = ast.schema.narrow(resolved, ast.schema.types.intersection) ?? ast.schema.narrow(resolved, ast.schema.types.union);
 	if (!composition) return false;
-	return composition.type === ast.schemaTypes.intersection && !composition.members?.length || (composition.members ?? []).some((member) => isObjectSchema(member, seen));
+	return composition.type === ast.schema.types.intersection && !composition.members?.length || (composition.members ?? []).some((member) => isObjectSchema(member, seen));
 }
 function shouldInlineSingleResponseSchema(schema) {
 	return !NON_INLINABLE_RESPONSE_TYPES.has(schema.type);
 }
 /**
-* Builds a response schema as a union of all response statuses.
+* Builds a response schema as a union of the success response statuses, like the `<Operation>Response` type of
+* `@kubb/plugin-ts`, so the mock never is an error body. Falls back to every response when no success response has a schema.
 * Returns null if no responses are provided, or embeds single simple responses inline.
 */
 function buildResponseUnionSchema(node, resolver) {
-	const responses = node.responses.map((response) => ({
+	const withSchema = node.responses.map((response) => ({
 		...response,
 		content: response.content?.map((entry, _, content) => toResponseContent(entry, content))
 	})).filter((response) => response.content?.[0]?.schema);
+	const success = withSchema.filter((response) => ast.http.status.isSuccess(response));
+	const responses = success.length > 0 ? success : withSchema;
 	if (!responses.length) return null;
 	if (responses.length === 1) {
 		const schemas = responses[0].content?.flatMap((content) => content.schema ? [content.schema] : []) ?? [];
@@ -890,7 +740,7 @@ function getScalarType(node, typeName) {
 * Determines the data type, return type, and whether it uses the type name.
 */
 function resolveFakerTypeUsage(node, typeName, canOverride) {
-	const resolvedNode = ast.resolveRef(node);
+	const resolvedNode = ast.ref.getSchema(node);
 	const scalarType = SCALAR_TYPES.has(resolvedNode.type) ? `${getScalarType(resolvedNode, typeName)}${node.nullable || resolvedNode.nullable ? " | null" : ""}` : void 0;
 	const dataType = scalarType ?? `Partial<${typeName}>`;
 	const returnType = scalarType ?? (canOverride ? typeName : null);
@@ -909,8 +759,8 @@ function Faker({ node, description, name, typeName, printer, canOverride, typeMo
 		imp.name
 	].join("-")));
 	const isArray = node.type === "array";
-	const isObject = !!ast.narrowSchema(node, ast.schemaTypes.object) || node.type === ast.schemaTypes.intersection && isObjectSchema(node);
-	const isValueIntersection = node.type === ast.schemaTypes.intersection && !isObject;
+	const isObject = !!ast.schema.narrow(node, ast.schema.types.object) || node.type === ast.schema.types.intersection && isObjectSchema(node);
+	const isValueIntersection = node.type === ast.schema.types.intersection && !isObject;
 	const isTuple = node.type === "tuple";
 	const isScalar = SCALAR_TYPES.has(node.type);
 	const isUnion = node.type === "union";
@@ -919,13 +769,14 @@ function Faker({ node, description, name, typeName, printer, canOverride, typeMo
 		if (canOverride && node.type === "tuple") return `data && data.length === ${node.items?.length ?? 0} && !data.includes(undefined) ? data : ${fakerText}`;
 		if (canOverride && isArray) return `[\n  ...${fakerText},\n  ...(data || []).filter((item) => item !== undefined),\n]`;
 		if (canOverride && (isScalar || isUnion || isValueIntersection)) return node.nullable ? `data !== undefined ? data : ${fakerText}` : `data ?? ${fakerText}`;
+		if (canOverride && node.type === "ref" && node.nullable && SCALAR_TYPES.has(ast.ref.getSchema(node).type)) return `data === null ? data : ${fakerText}`;
 		return fakerText;
 	})();
 	const { dataType, returnType: resolvedReturnType } = resolveFakerTypeUsage(node, typeName, canOverride);
 	if (!useObjectOverride) {
 		const paramsSignature = `${/\bdata\b/.test(fakerTextWithOverride) ? "data" : "_data"}?: ${dataType}`;
 		const returnType = resolvedReturnType;
-		const returnExpression = canOverride && !!returnType && (node.type === "ref" && !SCALAR_TYPES.has(ast.resolveRef(node).type) || isArray || isTuple || isUnion) ? `${isTuple || isUnion ? `(${fakerTextWithOverride})` : fakerTextWithOverride} as ${returnType}` : fakerTextWithOverride;
+		const returnExpression = canOverride && !!returnType && (node.type === "ref" && !SCALAR_TYPES.has(ast.ref.getSchema(node).type) || isArray || isTuple || isUnion) ? `${isTuple || isUnion ? `(${fakerTextWithOverride})` : fakerTextWithOverride} as ${returnType}` : fakerTextWithOverride;
 		return /* @__PURE__ */ jsxs(Fragment, { children: [imports, /* @__PURE__ */ jsx(File.Source, {
 			name,
 			isExportable: true,
@@ -943,10 +794,11 @@ function Faker({ node, description, name, typeName, printer, canOverride, typeMo
 	const { cyclicSchemas, schemaName } = printer.options;
 	const isCyclic = !!schemaName && !!cyclicSchemas?.has(schemaName);
 	const returnType = typeMode === "schema" ? typeName : `Omit<${isCyclic ? typeName : "typeof defaultFakeData"}, keyof NoInfer<TData>> & NoInfer<TData>`;
-	const hasGetters = node.type === "object" && !!cyclicSchemas && (node.properties ?? []).some((p) => containsCircularRef(p.schema, {
+	const hasGetters = node.type === "object" && !!cyclicSchemas && (node.properties ?? []).some((p) => ast.graph.containsCircular(p.schema, {
 		circularSchemas: cyclicSchemas,
 		excludeName: schemaName
 	}));
+	const castThroughUnknown = (node.type !== "object" || node.min !== void 0) && typeMode !== "schema";
 	const declaration = `const ${keysToOmit?.length ? `{ ${keysToOmit.map((key, index) => `${objectKey(key)}: _omit${index}`).join(", ")}, ...defaultFakeData }` : "defaultFakeData"} = ${fakerText}`;
 	const functionBody = hasGetters ? `${declaration}
 if (data) {
@@ -958,7 +810,7 @@ return defaultFakeData as ${returnType}` : `${declaration}
 return {
   ...defaultFakeData,
   ...(data || {}),
-} as ${returnType}`;
+} as ${castThroughUnknown ? "unknown as " : ""}${returnType}`;
 	return /* @__PURE__ */ jsxs(Fragment, { children: [imports, /* @__PURE__ */ jsx(File.Source, {
 		name,
 		isExportable: true,
@@ -1035,11 +887,38 @@ const integerFormats = /* @__PURE__ */ new Set([
 	"uint64"
 ]);
 const maxInt32 = 2147483647;
+const maxValueByFormat = {
+	int32: maxInt32,
+	uint32: 4294967295
+};
+function isCyclicRef(node, { schemaName, cyclicSchemas }) {
+	if (node.type !== "ref" || !schemaName) return false;
+	const refName = ast.ref.getName(node);
+	return refName === schemaName || Boolean(refName && cyclicSchemas?.has(schemaName) && cyclicSchemas.has(refName));
+}
 /**
-* `faker.number.float()` or `faker.number.int()`, with `min` and `max` passed only when set.
+* `faker.number.float()`, `faker.number.int()` or `faker.number.bigInt()`, with `min` and `max` passed only when set,
+* moved inside an exclusive bound, or needed so a lone bound does not contradict faker's default for the other.
 */
-function numberCall(kind, min, max) {
-	const args = [min !== void 0 && `min: ${min}`, max !== void 0 && `max: ${max}`].filter(Boolean).join(", ");
+function numberCall(kind, { min, max, exclusive, multipleOf }) {
+	const isWhole = kind !== "float";
+	const grid = isWhole && !Number.isInteger(multipleOf) ? void 0 : multipleOf;
+	const { min: lower, max: upper } = ast.schema.getNumberBounds({
+		min,
+		max,
+		exclusive,
+		integer: isWhole,
+		step: grid
+	});
+	const span = 100 * (grid ?? 1);
+	const maxValue = kind === "float" && lower !== void 0 && upper === void 0 && (lower >= 1 || grid !== void 0) ? lower + span : upper;
+	const minValue = maxValue !== void 0 && lower === void 0 && (isWhole ? maxValue < 0 : maxValue <= 0) ? maxValue - span : lower;
+	const suffix = kind === "bigInt" ? "n" : "";
+	const args = [
+		minValue !== void 0 && `min: ${minValue}${suffix}`,
+		maxValue !== void 0 && `max: ${maxValue}${suffix}`,
+		grid !== void 0 && `multipleOf: ${grid}${suffix}`
+	].filter(Boolean).join(", ");
 	return `faker.number.${kind}(${args ? `{ ${args} }` : ""})`;
 }
 /**
@@ -1057,12 +936,58 @@ function dateTimeCall(representation, { format, substring }, parser = "faker", s
 	});
 	return "faker.date.anytime()";
 }
+const encodingCalls = /* @__PURE__ */ new Map([["base64", "btoa(faker.string.alpha())"], ["base64url", "faker.string.alphanumeric(8)"]]);
+const stringFormatCalls = /* @__PURE__ */ new Map([
+	["jwt", "faker.internet.jwt()"],
+	["ulid", "faker.string.ulid()"],
+	["iban", "faker.finance.iban()"],
+	["duration", "'P1D'"],
+	["hostname", "faker.internet.domainName()"]
+]);
+const classEscapes = new Map([
+	["d", "0-9"],
+	["w", "A-Za-z0-9_"],
+	...Array.from("-!@#$&()`.+,\"", (char) => [char, char])
+]);
+function toFakerPattern(pattern) {
+	let result = "";
+	let inClass = false;
+	let classStart = -1;
+	for (let index = 0; index < pattern.length; index++) {
+		const char = pattern[index];
+		const next = pattern[index + 1];
+		if (char === "\\" && next !== void 0) {
+			index++;
+			if (inClass && next === "-") {
+				if (result[classStart] !== "-") result = `${result.slice(0, classStart)}-${result.slice(classStart)}`;
+				continue;
+			}
+			const classMembers = classEscapes.get(next);
+			if (classMembers === void 0) {
+				result += `\\${next}`;
+				continue;
+			}
+			result += inClass ? classMembers : `[${classMembers}]`;
+			continue;
+		}
+		if (char === "[" && !inClass) {
+			inClass = true;
+			result += next === "^" ? "[^" : "[";
+			if (next === "^") index++;
+			classStart = result.length;
+			continue;
+		}
+		if (char === "]") inClass = false;
+		result += char;
+	}
+	return result.replace(/\{(\d+),\}/g, (_, min) => `{${min},${Number(min) + 10}}`);
+}
 function matches(value, regexGenerator = "faker") {
 	if (regexGenerator === "randexp") return `${toRegExpString(value, "RandExp")}.gen()`;
-	return `faker.helpers.fromRegExp(${toRegExpString(value, null)})`;
+	return `faker.helpers.fromRegExp(${toRegExpString(toFakerPattern(value), null)})`;
 }
 function parseEnumValue(value) {
-	if (typeof value === "string") return stringify(value);
+	if (typeof value === "string") return text.quote(value);
 	return value;
 }
 /**
@@ -1073,11 +998,11 @@ function parseEnumValue(value) {
 * (a `ref` to the enum shared by every branch, say) identifies no branch and narrows nothing.
 */
 function getDiscriminator(member, discriminatorPropertyName) {
-	for (const property of ast.resolveSchemaProperties({
+	for (const property of ast.schema.findProperties({
 		node: member,
 		propertyName: discriminatorPropertyName
 	})) {
-		const values = ast.getSchemaLiteralValues(property.schema);
+		const values = ast.schema.getLiterals(property.schema);
 		if (values.length === 1) return {
 			value: values[0],
 			required: property.required
@@ -1094,11 +1019,14 @@ function indexedTypeName(typeName, propertyName, nestedInUnion) {
 	const key = JSON.stringify(propertyName);
 	return nestedInUnion ? `(NonNullable<${typeName}> & Record<${key}, unknown>)[${key}]` : `NonNullable<${typeName}>[${key}]`;
 }
+function itemTypeName(typeName, nestedInUnion) {
+	return nestedInUnion ? `Extract<NonNullable<${typeName}>, ReadonlyArray<unknown>>[number]` : `NonNullable<${typeName}>[number]`;
+}
 /**
 * Creates a Faker printer that generates mock data generation code from schema nodes.
 * Handles circular references gracefully by emitting memoizing getters for cyclic properties.
 */
-const printerFaker = ast.createPrinter((options) => {
+const printerFaker = createPrinter((options) => {
 	const printNested = (node, overrideOptions = {}) => {
 		return printerFaker({
 			...options,
@@ -1118,18 +1046,33 @@ const printerFaker = ast.createPrinter((options) => {
 			string(node) {
 				if (node.pattern) return matches(node.pattern, this.options.regexGenerator);
 				if (node.format && integerFormats.has(node.format)) return node.format === "int32" ? `faker.number.int({ max: ${maxInt32} }).toString()` : "faker.number.bigInt().toString()";
+				const formatCall = stringFormatCalls.get(node.format);
+				if (formatCall) return formatCall;
+				const contentSchema = ast.schema.getEmbeddedJson(node);
+				if (contentSchema) return `JSON.stringify(${printNested(contentSchema, {
+					typeName: void 0,
+					nestedInObject: true,
+					nestedInUnion: false
+				})})`;
+				const encodingCall = encodingCalls.get(node.content?.encoding?.toLowerCase());
+				if (encodingCall) return encodingCall;
 				const { min, max } = node;
-				if (min !== void 0 && max !== void 0) return `faker.string.alpha({ length: { min: ${min}, max: ${max} } })`;
-				if (max !== void 0 || min !== void 0) return `faker.string.alpha({ length: ${max ?? min} })`;
+				if (max !== void 0) return `faker.string.alpha({ length: { min: ${min ?? Math.min(1, max)}, max: ${Math.min(max, (min ?? 0) + 100)} } })`;
+				if (min !== void 0) return `faker.string.alpha({ length: ${min} })`;
 				return "faker.string.alpha()";
 			},
 			email: () => "faker.internet.email()",
 			url: () => "faker.internet.url()",
 			uuid: () => "faker.string.uuid()",
-			number: (node) => numberCall("float", node.min, node.max),
-			integer: (node) => numberCall("int", node.min, node.max),
-			bigint: () => "faker.number.bigInt()",
-			blob: () => "faker.image.url() as unknown as Blob",
+			ipv4: () => "faker.internet.ipv4()",
+			ipv6: () => "faker.internet.ipv6()",
+			number: (node) => numberCall("float", node),
+			integer: (node) => numberCall("int", node.format && node.format in maxValueByFormat ? {
+				...node,
+				max: Math.min(node.max ?? Infinity, maxValueByFormat[node.format])
+			} : node),
+			bigint: (node) => numberCall("bigInt", node),
+			blob: () => "new Blob([faker.string.alpha()])",
 			datetime(node) {
 				const parser = this.options.dateParser ?? "faker";
 				if (parser === "faker") return "faker.date.anytime().toISOString()";
@@ -1148,28 +1091,30 @@ const printerFaker = ast.createPrinter((options) => {
 				}, this.options.dateParser, this.options.schemaName);
 			},
 			ref(node) {
-				const refName = ast.resolveRefName(node);
+				const refName = ast.ref.getName(node);
 				if (!refName) throw new Diagnostics.Error({
 					code: Diagnostics.code.pluginFailed,
 					severity: "error",
 					message: `Ref node "${node.ref ?? node.name ?? "unknown"}"${this.options.schemaName ? ` in schema "${this.options.schemaName}"` : ""} has no name.`,
 					plugin: "plugin-faker"
 				});
-				if (this.options.schemaName && refName === this.options.schemaName) return this.options.typeName ? `undefined as unknown as ${this.options.typeName}` : "undefined as unknown";
+				if (isCyclicRef(node, this.options)) return this.options.typeName ? `undefined as unknown as ${this.options.typeName}` : "undefined as unknown";
 				const resolvedName = node.ref ? this.options.resolver.name(refName) : refName;
-				if (!this.options.nestedInObject && canOverrideSchema(ast.resolveRef(node))) return `${resolvedName}(data)`;
+				if (!this.options.nestedInObject && canOverrideSchema(ast.ref.getSchema(node))) return `${resolvedName}(data)`;
 				return `${resolvedName}()`;
 			},
 			enum(node) {
 				const { typeName } = this.options;
-				const values = ast.getSchemaLiteralValues(node);
+				const values = ast.schema.getLiterals(node);
 				if (values.length === 1 && values[0] !== null && typeof values[0] === "object") return JSON.stringify(values[0]);
-				return `faker.helpers.arrayElement${typeName ? `<${typeName}>` : ""}([${values.map(parseEnumValue).join(", ")}])`;
+				return `faker.helpers.arrayElement([${values.map(parseEnumValue).join(", ")}]${typeName ? ` as Array<${typeName}>` : ""})`;
 			},
 			union(node) {
 				const { discriminatorPropertyName } = node;
 				const baseTypeName = this.options.typeName;
-				return `faker.helpers.arrayElement([${mapSchemaMembers(node, (member) => {
+				const isCyclicMember = (member) => isCyclicRef(member, this.options) || member.type === "intersection" && (member.members ?? []).some((part) => isCyclicRef(part, this.options));
+				const acyclicMembers = (node.members ?? []).filter((member) => !isCyclicMember(member));
+				return `faker.helpers.arrayElement([${((acyclicMembers.length ? acyclicMembers : node.members) ?? []).map((member) => {
 					const discriminator = discriminatorPropertyName ? getDiscriminator(member, discriminatorPropertyName) : void 0;
 					if (baseTypeName && discriminator) {
 						const key = `${JSON.stringify(discriminatorPropertyName)}${discriminator.required ? "" : "?"}`;
@@ -1185,29 +1130,31 @@ const printerFaker = ast.createPrinter((options) => {
 						nestedInObject: true,
 						nestedInUnion: true
 					});
-				}).map(({ output }) => output).filter((item) => Boolean(item)).join(", ")}])`;
+				}).filter((item) => Boolean(item)).join(", ")}])`;
 			},
 			intersection(node) {
 				const objectMembers = (node.members ?? []).filter((member) => isObjectSchema(member));
-				const members = objectMembers.length ? objectMembers : node.members;
-				const items = mapSchemaMembers({
-					...node,
-					members
-				}, (member) => printNested(member, { nestedInObject: true })).map(({ output }) => output).filter((item) => Boolean(item) && item !== "undefined");
+				const memberRank = (member) => member.type === "ref" ? 0 : member.type === "union" ? 2 : 1;
+				const items = ((objectMembers.length ? objectMembers.toSorted((a, b) => memberRank(a) - memberRank(b)) : node.members) ?? []).map((member) => printNested(member, {
+					nestedInObject: true,
+					...member.type === "ref" && ast.ref.getName(member) !== this.options.schemaName ? { cyclicSchemas: void 0 } : {}
+				})).filter((item) => Boolean(item) && item !== "undefined");
 				if (items.length === 0) return "{}";
 				return !objectMembers.length || items.length === 1 ? items.at(-1) : `{...${items.join(", ...")}}`;
 			},
 			array(node) {
-				const items = mapSchemaItems(node, (member) => printNested(member, {
-					typeName: this.options.typeName ? `NonNullable<${this.options.typeName}>[number]` : void 0,
+				if (node.items?.length === 1 && isCyclicRef(node.items[0], this.options)) return this.options.typeName ? `[] as ${this.options.typeName}` : "[]";
+				const items = (node.items ?? []).map((member) => printNested(member, {
+					typeName: this.options.typeName ? itemTypeName(this.options.typeName, this.options.nestedInUnion) : void 0,
 					nestedInObject: true
-				})).map(({ output }) => output).filter((item) => Boolean(item));
+				})).filter((item) => Boolean(item));
 				if (items.length > 1) return `faker.helpers.arrayElements([${items.join(", ")}])`;
 				const { min, max } = node;
 				const item = items[0];
-				if (min !== void 0 && max !== void 0) return `faker.helpers.multiple(() => (${item}), { count: { min: ${min}, max: ${max} }})`;
+				const countRange = max === void 0 ? void 0 : `{ min: ${min ?? 0}, max: ${Math.min(max, (min ?? 0) + 100)} }`;
+				if (node.unique) return `faker.helpers.uniqueArray(() => (${item}), ${countRange ? `faker.number.int(${countRange})` : min ?? 3})`;
+				if (countRange) return `faker.helpers.multiple(() => (${item}), { count: ${countRange}})`;
 				if (min !== void 0) return `faker.helpers.multiple(() => (${item}), { count: ${min} })`;
-				if (max !== void 0) return `faker.helpers.multiple(() => (${item}), { count: { min: 0, max: ${max} }})`;
 				return `faker.helpers.multiple(() => (${item}))`;
 			},
 			tuple(node) {
@@ -1218,18 +1165,30 @@ const printerFaker = ast.createPrinter((options) => {
 			},
 			object(node) {
 				const cyclicSchemas = this.options.cyclicSchemas;
-				const keySchema = node.propertyNames && syncSchemaRef(node.propertyNames);
+				const keySchema = node.propertyNames && ast.ref.mergeSchema(node.propertyNames);
 				const valueSchema = node.additionalProperties;
-				const recordProperties = keySchema?.type === "enum" && typeof valueSchema === "object" ? ast.getSchemaLiteralValues(keySchema).filter((key) => typeof key === "string" && !node.properties.some((property) => property.name === key)).map((name) => ast.factory.createProperty({
+				const recordProperties = keySchema?.type === "enum" && typeof valueSchema === "object" ? ast.schema.getLiterals(keySchema).filter((key) => typeof key === "string" && !node.properties.some((property) => property.name === key)).map((name) => ast.factory.createProperty({
 					name,
 					schema: valueSchema
 				})) : [];
-				return buildObject([...node.properties, ...recordProperties].map((property) => {
+				const properties = [...node.properties, ...recordProperties];
+				const keptProperties = node.max === void 0 ? properties : properties.toSorted((a, b) => Number(b.required) - Number(a.required)).slice(0, node.max);
+				const declaredNames = new Set(properties.map((property) => property.name));
+				const extras = [];
+				for (let index = 1; typeof valueSchema === "object" && keptProperties.length + extras.length < (node.min ?? 0); index++) {
+					const name = `additionalProperty${index}`;
+					if (!declaredNames.has(name)) extras.push(ast.factory.createProperty({
+						name,
+						schema: valueSchema
+					}));
+				}
+				return buildObject([...keptProperties, ...extras].map((property) => {
 					const value = printNested(property.schema, {
 						typeName: this.options.typeName ? indexedTypeName(this.options.typeName, property.name, this.options.nestedInUnion) : void 0,
-						nestedInObject: true
+						nestedInObject: true,
+						...property.required && property.schema.type === "ref" ? { cyclicSchemas: void 0 } : {}
 					}) ?? "undefined";
-					if (cyclicSchemas && containsCircularRef(property.schema, {
+					if (cyclicSchemas && ast.graph.containsCircular(property.schema, {
 						circularSchemas: cyclicSchemas,
 						excludeName: this.options.schemaName
 					})) return `get ${objectKey(property.name)}() { const _value = ${value}; Object.defineProperty(this, ${JSON.stringify(property.name)}, { value: _value, configurable: true, writable: true, enumerable: true }); return _value }`;
@@ -1257,7 +1216,7 @@ const fakerGenerator = defineGenerator({
 		if (!node.name) return;
 		const tsResolver = ctx.driver.getResolver(pluginTsName);
 		const schemaName = node.name;
-		const isEnumSchema = !!ast.narrowSchema(node, ast.schemaTypes.enum);
+		const isEnumSchema = !!ast.schema.narrow(node, ast.schema.types.enum);
 		const schemaTypeName = enumTypeName({
 			resolver: tsResolver,
 			name: schemaName,
@@ -1306,7 +1265,8 @@ const fakerGenerator = defineGenerator({
 			node,
 			root,
 			output,
-			group: group ?? void 0
+			group: group ?? void 0,
+			checks: true
 		}), fakerText);
 		return /* @__PURE__ */ jsxs(File, {
 			baseName: meta.file.baseName,
@@ -1380,7 +1340,7 @@ const fakerGenerator = defineGenerator({
 		const { output, group, dateParser, regexGenerator, seed, locale, printer, typeMode } = ctx.options;
 		const pluginTs = ctx.requirePlugin(pluginTsName);
 		const tsResolver = ctx.driver.getResolver(pluginTsName);
-		const { path: pathParams, query: queryParams, header: headerParams, cookie: cookieParams } = getOperationParameters(node);
+		const { path: pathParams, query: queryParams, header: headerParams, cookie: cookieParams } = ast.http.groupParameters(node);
 		const paramGroups = [
 			{
 				params: pathParams,
@@ -1449,7 +1409,7 @@ const fakerGenerator = defineGenerator({
 			description: node.requestBody?.description ?? schema.description
 		}));
 		const responseName = resolver.response.response(node);
-		const hasResponseNameCollision = new Set(node.responses.flatMap((response) => (response.content ?? []).flatMap((entry) => entry.schema ? ast.collectImportedRefNames(entry.schema).map((name) => resolver.name(name)) : []))).has(responseName);
+		const hasResponseNameCollision = new Set(ast.http.responses.getImportedNames(node.responses).map((name) => resolver.name(name))).has(responseName);
 		const localHelperNames = /* @__PURE__ */ new Set([
 			...paramGroups.map((group) => group.name),
 			...responseUnits.map((unit) => unit.name),
@@ -1480,12 +1440,13 @@ const fakerGenerator = defineGenerator({
 				node: schema,
 				root,
 				output,
-				group: group ?? void 0
+				group: group ?? void 0,
+				checks: true
 			}).filter((entry) => entry.path !== meta.file.path);
 		}
 		function renderEntry({ schema, name, typeName, description, keysToOmit, skipImportNames = [] }) {
 			if (!schema) return null;
-			if (schema.type === ast.schemaTypes.object && keysToOmit?.length) {
+			if (schema.type === ast.schema.types.object && keysToOmit?.length) {
 				schema = {
 					...schema,
 					properties: schema.properties.filter((property) => !keysToOmit?.includes(property.name))
@@ -1600,11 +1561,11 @@ const fakerGenerator = defineGenerator({
 });
 // kubb-extension.json
 var compatibility = {
-	"kubb": ">=5.16.0",
+	"kubb": ">=5.18.4",
 	"node": ">=22.22"
 };
 // package.json
-var version = "5.4.0-canary.20261111T122006";
+var version = "5.4.0";
 // src/resolvers/resolverFaker.ts
 /**
 * Default resolver used by `@kubb/plugin-faker`. Decides the names and file
@@ -1621,9 +1582,9 @@ var version = "5.4.0-canary.20261111T122006";
 const resolverFaker = createResolver({
 	pluginName: "plugin-faker",
 	name(name) {
-		return this.memo(`name:${name}`, () => ensureValidVarName(camelCase(name, { prefix: "create" })));
+		return this.memo(`name:${name}`, () => ensureValidVarName(casing.camel(name, { prefix: "create" })));
 	},
-	file: createCasedFile((part) => camelCase(part, { prefix: "create" })),
+	file: createCasedFile((part) => casing.camel(part, { prefix: "create" })),
 	param: createOperationParamResolver(),
 	response: createOperationResponseResolver()
 });
@@ -1681,7 +1642,7 @@ const pluginFaker = defineExtension({
 			include,
 			override,
 			typeMode,
-			group: createGroupConfig(group),
+			group: group ?? null,
 			dateParser,
 			regexGenerator,
 			printer