@power-plant/schema 0.0.36 → 0.0.37

package/dist/index.cjs

@@ -1,29 +1,35 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_rolldown_runtime = require('./rolldown-runtime-C_NdSu1c.cjs');
 const require_constants = require('./constants-CEmLvTDd.cjs');
-const require_helpers = require('./helpers-CQS3qnsv.cjs');
+const require_helpers = require('./helpers-DbFdMcOB.cjs');
+const require_codegen = require('./codegen.cjs');
 const require_storage = require('./storage-B8aDmNpv.cjs');
 let _stryke_type_checks_is_set_object = require("@stryke/type-checks/is-set-object");
 let _stryke_type_checks_is_set_string = require("@stryke/type-checks/is-set-string");
 let _stryke_type_checks = require("@stryke/type-checks");
+let _deepkit_type = require("@deepkit/type");
+let _deepkit_type_compiler = require("@deepkit/type-compiler");
 let _stryke_convert_extract_file_reference = require("@stryke/convert/extract-file-reference");
 let _stryke_fs_resolve = require("@stryke/fs/resolve");
 let _stryke_hash = require("@stryke/hash");
 let _stryke_helpers_deep_clone = require("@stryke/helpers/deep-clone");
+let _stryke_helpers_omit = require("@stryke/helpers/omit");
 let _stryke_json = require("@stryke/json");
 let _stryke_path_append = require("@stryke/path/append");
 let _stryke_path_find = require("@stryke/path/find");
 let _stryke_path_join = require("@stryke/path/join");
 let _stryke_resolve_constants = require("@stryke/resolve/constants");
 let _stryke_resolve_load = require("@stryke/resolve/load");
-let _stryke_resolve_resolve = require("@stryke/resolve/resolve");
 let _stryke_string_format_list = require("@stryke/string-format/list");
 let _stryke_zod = require("@stryke/zod");
 let _valibot_to_json_schema = require("@valibot/to-json-schema");
-let ts_json_schema_generator_dist_factory_generator_js = require("ts-json-schema-generator/dist/factory/generator.js");
-let ts_json_schema_generator_dist_src_Config_js = require("ts-json-schema-generator/dist/src/Config.js");
+let esbuild = require("esbuild");
+let jiti = require("jiti");
+let node_fs_promises = require("node:fs/promises");
 let typescript = require("typescript");
 typescript = require_rolldown_runtime.__toESM(typescript, 1);
+let defu = require("defu");
+defu = require_rolldown_runtime.__toESM(defu, 1);
 
 //#region src/compatibility.ts
 const METADATA_KEYS = /* @__PURE__ */ new Set([
@@ -127,6 +133,412 @@ function assertSchemasDoNotContradict(base, override, label = "schema") {
 	if (issues.length > 0) throw new Error(`The ${label} schema contradicts the generator schema:\n${issues.map((issue) => `- ${issue}`).join("\n")}`);
 }
 
+//#endregion
+//#region src/reflection.ts
+/**
+* Maps a Deepkit numeric `brand` to JSON Schema `type` and `format`.
+*
+* @remarks
+* This function takes a `TypeNumberBrand` (which represents specific numeric types in Deepkit, such as `integer`, `float`, `int8`, etc.) and returns a corresponding JSON Schema fragment that includes the appropriate `type`, `format`, and any relevant keywords (like `multipleOf` for integers). If the brand is not recognized, it defaults to a generic JSON Schema for numbers.
+*
+* @param brand - The Deepkit numeric brand to convert.
+* @return A JSON Schema fragment representing the numeric type corresponding to the provided brand.
+*/
+function numberBrandToJsonSchema(brand) {
+	switch (brand) {
+		case _deepkit_type.TypeNumberBrand.integer: return {
+			type: "integer",
+			format: "int32",
+			multipleOf: 1
+		};
+		case _deepkit_type.TypeNumberBrand.int8: return {
+			type: "integer",
+			format: "int8",
+			multipleOf: 1
+		};
+		case _deepkit_type.TypeNumberBrand.uint8: return {
+			type: "integer",
+			format: "uint8",
+			multipleOf: 1
+		};
+		case _deepkit_type.TypeNumberBrand.int16: return {
+			type: "integer",
+			format: "int16",
+			multipleOf: 1
+		};
+		case _deepkit_type.TypeNumberBrand.uint16: return {
+			type: "integer",
+			format: "uint16",
+			multipleOf: 1
+		};
+		case _deepkit_type.TypeNumberBrand.int32: return {
+			type: "integer",
+			format: "int32",
+			multipleOf: 1
+		};
+		case _deepkit_type.TypeNumberBrand.uint32: return {
+			type: "integer",
+			format: "uint32",
+			multipleOf: 1
+		};
+		case _deepkit_type.TypeNumberBrand.float:
+		case _deepkit_type.TypeNumberBrand.float32: return {
+			type: "number",
+			format: "float"
+		};
+		case _deepkit_type.TypeNumberBrand.float64: return {
+			type: "number",
+			format: "double"
+		};
+		case void 0:
+		default: return { type: "number" };
+	}
+}
+function withReflectionTags(reflection, schema) {
+	if (!(0, _stryke_type_checks.isSetObject)(schema) || !(0, _stryke_type_checks.isSetObject)(reflection?.tags)) return schema;
+	const updatedSchema = { ...schema };
+	const tags = reflection.tags;
+	if ((0, _stryke_type_checks.isSetString)(tags.title)) updatedSchema.title = tags.title;
+	if ((0, _stryke_type_checks.isSetArray)(tags.alias)) updatedSchema.alias = tags.alias;
+	if (!(0, _stryke_type_checks.isUndefined)(tags.hidden)) updatedSchema.hidden = tags.hidden;
+	if (!(0, _stryke_type_checks.isUndefined)(tags.ignore)) updatedSchema.ignore = tags.ignore;
+	if (!(0, _stryke_type_checks.isUndefined)(tags.internal)) updatedSchema.internal = tags.internal;
+	if (!(0, _stryke_type_checks.isUndefined)(tags.runtime)) updatedSchema.runtime = tags.runtime;
+	if (!(0, _stryke_type_checks.isUndefined)(tags.readonly)) updatedSchema.readOnly = tags.readonly;
+	return updatedSchema;
+}
+function withNullable(schema) {
+	if (!(0, _stryke_type_checks.isSetObject)(schema)) return { anyOf: [schema, {
+		type: "null",
+		default: null
+	}] };
+	const rawType = schema.type;
+	const types = Array.isArray(rawType) ? [...rawType] : rawType ? [rawType] : [];
+	if (!types.includes("null")) types.push("null");
+	return {
+		...schema,
+		type: types.length === 1 ? types[0] : types
+	};
+}
+/**
+* Converts a Deepkit type reflection into a JSON Schema (draft-07) fragment.
+*/
+function reflectionToJsonSchema(reflection) {
+	return reflectionToJsonSchemaInner(reflection);
+}
+function reflectionToJsonSchemaInner(reflection) {
+	switch (reflection.kind) {
+		case _deepkit_type.ReflectionKind.any:
+		case _deepkit_type.ReflectionKind.unknown:
+		case _deepkit_type.ReflectionKind.void:
+		case _deepkit_type.ReflectionKind.object: return withReflectionTags(reflection, { name: reflection.typeName });
+		case _deepkit_type.ReflectionKind.never: return;
+		case _deepkit_type.ReflectionKind.undefined:
+		case _deepkit_type.ReflectionKind.null: return withReflectionTags(reflection, {
+			type: "null",
+			name: reflection.typeName,
+			default: null
+		});
+		case _deepkit_type.ReflectionKind.string: return withReflectionTags(reflection, {
+			type: "string",
+			name: reflection.typeName
+		});
+		case _deepkit_type.ReflectionKind.boolean: return withReflectionTags(reflection, {
+			type: "boolean",
+			name: reflection.typeName
+		});
+		case _deepkit_type.ReflectionKind.number: return withReflectionTags(reflection, numberBrandToJsonSchema(reflection.brand));
+		case _deepkit_type.ReflectionKind.bigint: return withReflectionTags(reflection, {
+			type: "integer",
+			name: reflection.typeName,
+			format: "int64"
+		});
+		case _deepkit_type.ReflectionKind.regexp: return withReflectionTags(reflection, {
+			type: "string",
+			name: reflection.typeName,
+			format: "regex",
+			contentMediaType: "text/regex"
+		});
+		case _deepkit_type.ReflectionKind.literal: {
+			const { literal } = reflection;
+			if ((0, _stryke_type_checks.isBigInt)(literal)) return withReflectionTags(reflection, {
+				type: "integer",
+				name: reflection.typeName,
+				format: "int64",
+				const: literal
+			});
+			if ((0, _stryke_type_checks.isRegExp)(literal)) return withReflectionTags(reflection, {
+				type: "string",
+				name: reflection.typeName,
+				format: "regex",
+				const: literal.source
+			});
+			return withReflectionTags(reflection, {
+				type: require_codegen.getJsonSchemaType(literal),
+				name: reflection.typeName,
+				const: literal
+			});
+		}
+		case _deepkit_type.ReflectionKind.templateLiteral: return withReflectionTags(reflection, { type: "string" });
+		case _deepkit_type.ReflectionKind.enum: {
+			const values = reflection.values.filter((value) => (0, _stryke_type_checks.isString)(value) || (0, _stryke_type_checks.isInteger)(value) || (0, _stryke_type_checks.isBigInt)(value) || (0, _stryke_type_checks.isNumber)(value) || (0, _stryke_type_checks.isBoolean)(value) || (0, _stryke_type_checks.isNull)(value));
+			if (values.length === 0) return withReflectionTags(reflection, {
+				name: reflection.typeName,
+				description: reflection.description,
+				enum: []
+			});
+			return withReflectionTags(reflection, {
+				type: values.every((value) => (0, _stryke_type_checks.isString)(value)) ? "string" : values.every((value) => (0, _stryke_type_checks.isInteger)(value) || (0, _stryke_type_checks.isBigInt)(value)) ? "integer" : values.every((value) => (0, _stryke_type_checks.isNumber)(value)) ? "number" : values.every((value) => (0, _stryke_type_checks.isBoolean)(value)) ? "boolean" : values.every((value) => (0, _stryke_type_checks.isNull)(value)) ? "null" : values.reduce((ret, value) => {
+					const type = require_codegen.getJsonSchemaType(value);
+					if (require_helpers.isJsonSchemaPrimitiveType(type) && !ret.includes(type)) ret.push(type);
+					return ret;
+				}, []),
+				name: reflection.typeName,
+				description: reflection.description,
+				enum: values,
+				default: values.length === 1 ? values[0] : void 0
+			});
+		}
+		case _deepkit_type.ReflectionKind.array: {
+			const items = reflectionToJsonSchemaInner(reflection.type);
+			return withReflectionTags(reflection, {
+				type: "array",
+				name: reflection.typeName,
+				items: items ?? {}
+			});
+		}
+		case _deepkit_type.ReflectionKind.tuple: {
+			const items = reflection.types.map((member) => reflectionToJsonSchemaInner(member.type)).filter((item) => item !== void 0);
+			if (items.length <= 1) return withReflectionTags(reflection, {
+				type: "array",
+				name: reflection.typeName,
+				items: items.length === 1 ? items[0] : {}
+			});
+			return withReflectionTags(reflection, {
+				type: "array",
+				name: reflection.typeName,
+				prefixItems: items,
+				minItems: items.length,
+				maxItems: items.length
+			});
+		}
+		case _deepkit_type.ReflectionKind.union: {
+			const branches = reflection.types.map((inner) => reflectionToJsonSchemaInner(inner)).filter((branch) => branch !== void 0);
+			if (!reflection.types.some((inner) => inner.kind === _deepkit_type.ReflectionKind.null || inner.kind === _deepkit_type.ReflectionKind.undefined)) return withReflectionTags(reflection, {
+				name: reflection.typeName,
+				anyOf: branches
+			});
+			const nonNull = branches.filter((branch) => !require_helpers.isNullOnlyJsonSchema(branch));
+			if (nonNull.length === 0) return withReflectionTags(reflection, {
+				type: "null",
+				default: null
+			});
+			if (nonNull.length === 1) {
+				const first = nonNull[0];
+				if (!(0, _stryke_type_checks.isSetObject)(first)) return withNullable(withReflectionTags(reflection, {
+					name: reflection.typeName,
+					anyOf: [first]
+				}));
+				return withNullable(withReflectionTags(reflection, {
+					name: reflection.typeName,
+					...first
+				}));
+			}
+			const enumValues = nonNull.map((branch) => (0, _stryke_type_checks.isSetObject)(branch) ? branch.const : void 0).filter((value) => value === null || typeof value === "string" || typeof value === "number" || typeof value === "bigint" || typeof value === "boolean");
+			if (enumValues.length === nonNull.length) return withNullable(withReflectionTags(reflection, {
+				name: reflection.typeName,
+				enum: enumValues
+			}));
+			const discriminator = tryReflectionDiscriminator(reflection.types);
+			if (discriminator && (0, _stryke_type_checks.isSetObject)(discriminator)) return withNullable(withReflectionTags(reflection, {
+				name: reflection.typeName,
+				...discriminator
+			}));
+			return withNullable(withReflectionTags(reflection, {
+				name: reflection.typeName,
+				anyOf: nonNull
+			}));
+		}
+		case _deepkit_type.ReflectionKind.intersection: {
+			const members = reflection.types.map((inner) => reflectionToJsonSchemaInner(inner)).filter((item) => item !== void 0);
+			if (members.length === 0) return;
+			if (members.length === 1) {
+				if (!(0, _stryke_type_checks.isSetObject)(members[0])) return members[0];
+				return withReflectionTags(reflection, {
+					name: reflection.typeName,
+					...members[0]
+				});
+			}
+			if (members.every(require_helpers.isJsonSchemaObject)) return withReflectionTags(reflection, {
+				name: reflection.typeName,
+				...mergeObjectSchemas(members)
+			});
+			return withReflectionTags(reflection, {
+				name: reflection.typeName,
+				allOf: members
+			});
+		}
+		case _deepkit_type.ReflectionKind.promise: return reflectionToJsonSchemaInner(reflection.type);
+		case _deepkit_type.ReflectionKind.objectLiteral: return objectReflectionToJsonSchema(reflection);
+		case _deepkit_type.ReflectionKind.class: switch (reflection.classType?.name) {
+			case "Date": return withReflectionTags(reflection, {
+				type: "string",
+				format: "date-time"
+			});
+			case "RegExp": return withReflectionTags(reflection, {
+				type: "string",
+				format: "regex"
+			});
+			case "URL": return withReflectionTags(reflection, {
+				type: "string",
+				format: "uri"
+			});
+			case "Set": {
+				const itemType = reflection.arguments?.[0];
+				return withReflectionTags(reflection, {
+					type: "array",
+					items: (itemType ? reflectionToJsonSchemaInner(itemType) : void 0) ?? {},
+					uniqueItems: true
+				});
+			}
+			case "Map": {
+				const valueType = reflection.arguments?.[1];
+				return withReflectionTags(reflection, {
+					type: "object",
+					additionalProperties: (valueType ? reflectionToJsonSchemaInner(valueType) : void 0) ?? true
+				});
+			}
+			case "Uint8Array":
+			case "Uint8ClampedArray":
+			case "Uint16Array":
+			case "Uint32Array":
+			case "Int8Array":
+			case "Int16Array":
+			case "Int32Array":
+			case "Float32Array":
+			case "Float64Array":
+			case "BigInt64Array":
+			case "BigUint64Array": return withReflectionTags(reflection, {
+				type: "string",
+				format: "byte",
+				contentEncoding: "base64"
+			});
+			case void 0:
+			default: return withReflectionTags(reflection, {
+				name: reflection.typeName,
+				description: reflection.description,
+				...objectReflectionToJsonSchema(reflection)
+			});
+		}
+		case _deepkit_type.ReflectionKind.symbol:
+		case _deepkit_type.ReflectionKind.property:
+		case _deepkit_type.ReflectionKind.method:
+		case _deepkit_type.ReflectionKind.function:
+		case _deepkit_type.ReflectionKind.parameter:
+		case _deepkit_type.ReflectionKind.typeParameter:
+		case _deepkit_type.ReflectionKind.tupleMember:
+		case _deepkit_type.ReflectionKind.enumMember:
+		case _deepkit_type.ReflectionKind.rest:
+		case _deepkit_type.ReflectionKind.indexSignature:
+		case _deepkit_type.ReflectionKind.propertySignature:
+		case _deepkit_type.ReflectionKind.methodSignature:
+		case _deepkit_type.ReflectionKind.infer:
+		case _deepkit_type.ReflectionKind.callSignature:
+		default: return;
+	}
+}
+function mergeObjectSchemas(schemas) {
+	const merged = {
+		type: "object",
+		properties: {},
+		required: []
+	};
+	for (const schema of schemas) {
+		if (schema.properties) merged.properties = (0, defu.default)(merged.properties, schema.properties);
+		if (schema.required) merged.required = Array.from(/* @__PURE__ */ new Set([...merged.required ?? [], ...schema.required]));
+		if (schema.additionalProperties !== void 0) merged.additionalProperties = schema.additionalProperties;
+	}
+	if ((merged.required?.length ?? 0) === 0) delete merged.required;
+	return merged;
+}
+function tryReflectionDiscriminator(types) {
+	const nonNullTypes = types.filter((t) => t.kind !== _deepkit_type.ReflectionKind.null && t.kind !== _deepkit_type.ReflectionKind.undefined);
+	const objectBranches = nonNullTypes.filter((t) => t.kind === _deepkit_type.ReflectionKind.objectLiteral || t.kind === _deepkit_type.ReflectionKind.class);
+	if (objectBranches.length < 2 || objectBranches.length !== nonNullTypes.length) return;
+	let tagKey;
+	const branches = [];
+	for (const branch of objectBranches) {
+		const literalProps = [];
+		for (const member of branch.types) if ((member.kind === _deepkit_type.ReflectionKind.property || member.kind === _deepkit_type.ReflectionKind.propertySignature) && typeof member.name === "string" && member.type.kind === _deepkit_type.ReflectionKind.literal && typeof member.type.literal === "string") literalProps.push({
+			name: member.name,
+			literal: member.type.literal
+		});
+		if (literalProps.length === 0) return;
+		const first = literalProps[0];
+		if (!tagKey) tagKey = first.name;
+		else if (tagKey !== first.name) return;
+		const body = objectReflectionToJsonSchema({
+			...branch,
+			types: branch.types.filter((member) => !((member.kind === _deepkit_type.ReflectionKind.property || member.kind === _deepkit_type.ReflectionKind.propertySignature) && member.name === tagKey))
+		});
+		if (!body || !require_helpers.isJsonSchemaObject(body)) return;
+		branches.push({
+			type: "object",
+			properties: {
+				[tagKey]: { const: first.literal },
+				...body.properties ?? {}
+			},
+			required: [tagKey, ...body.required ?? []],
+			additionalProperties: body.additionalProperties ?? false
+		});
+	}
+	if (!tagKey) return;
+	return {
+		oneOf: branches,
+		discriminator: { propertyName: tagKey }
+	};
+}
+function objectReflectionToJsonSchema(type) {
+	const reflection = _deepkit_type.ReflectionClass.from(type);
+	const schema = {
+		type: "object",
+		name: reflection.getName(),
+		description: reflection.getDescription(),
+		properties: {},
+		required: [],
+		primaryKey: reflection.getPrimaries().map((primary) => primary.getNameAsString()),
+		...(0, _stryke_type_checks.isSetString)(reflection.databaseSchemaName) ? { databaseSchemaName: reflection.databaseSchemaName } : {},
+		...(0, _stryke_type_checks.isSetString)(reflection.getName()) ? { name: reflection.getName() } : {},
+		...(0, _stryke_type_checks.isSetString)(reflection.getDescription()) ? { description: reflection.getDescription() } : {}
+	};
+	for (const propertyReflection of reflection.getProperties()) {
+		if (propertyReflection.getKind() === _deepkit_type.ReflectionKind.indexSignature) {
+			schema.additionalProperties = reflectionToJsonSchemaInner(propertyReflection.type) ?? true;
+			continue;
+		}
+		let property = reflectionToJsonSchemaInner(propertyReflection.type);
+		if (!property) continue;
+		const propertySchema = (0, _stryke_type_checks.isSetObject)(property) ? property : {};
+		const groups = propertyReflection.getGroups();
+		property = {
+			...propertySchema,
+			name: propertyReflection.getNameAsString(),
+			description: propertyReflection.getDescription(),
+			readOnly: propertyReflection.isReadonly(),
+			...propertyReflection.hasDefault() ? { default: propertyReflection.getDefaultValue() } : {},
+			...(0, _stryke_type_checks.isSetArray)(groups) ? { tags: groups } : {}
+		};
+		if (propertyReflection.isNullable()) property = withNullable(property);
+		schema.properties ??= {};
+		schema.properties[propertyReflection.name] = property;
+		if (!propertyReflection.isOptional()) {
+			schema.required ??= [];
+			schema.required.push(propertyReflection.name);
+		}
+	}
+	return schema;
+}
+
 //#endregion
 //#region src/extract.ts
 const SCHEMA_BUNDLE_BASE_URI = "https://power-plant.invalid/";
@@ -332,6 +744,10 @@ function extractHash(variant, input) {
 			variant,
 			input: unwrappedConfig._def
 		});
+		else if ((0, _deepkit_type.isType)(unwrappedConfig)) return (0, _stryke_hash.murmurhash)({
+			variant,
+			input: (0, _deepkit_type.stringifyType)(unwrappedConfig)
+		});
 		else if ((0, _stryke_json.isStandardJsonSchema)(unwrappedConfig)) return (0, _stryke_hash.murmurhash)({
 			variant,
 			input: unwrappedConfig["~standard"]
@@ -356,6 +772,13 @@ function extractHash(variant, input) {
 	throw new Error(`Failed to create an input hash for the provided schema definition input. The input must be a Zod schema, a Standard JSON Schema, a JSON Schema object, a Valibot BaseSchema, or a reflected Deepkit Type object.`);
 }
 /**
+* Converts a reflected Deepkit {@link Type} into a JSON Schema (draft-2020-12) representation.
+*/
+function extractReflection(reflection) {
+	if (!(0, _deepkit_type.isType)(reflection)) return;
+	return reflectionToJsonSchema(reflection);
+}
+/**
 * Extracts a JSON Schema from Zod, Standard Schema, Valibot, untyped, or JSON Schema inputs.
 *
 * @param schema - The schema input to extract a JSON Schema from.
@@ -381,6 +804,7 @@ function extractJsonSchema(schema) {
 function extractResolvedVariant(input) {
 	if ((0, _stryke_type_checks_is_set_object.isSetObject)(input)) {
 		if ((0, _stryke_zod.isZod3Type)(input)) return "zod3";
+		else if ((0, _deepkit_type.isType)(input)) return "reflection";
 		else if (require_helpers.isUntypedConfigStrict(input) || require_helpers.isUntypedSchemaStrict(input)) return "untyped";
 		else if ((0, _stryke_json.isStandardJsonSchema)(input)) return "standard-schema";
 		else if (require_helpers.isJsonSchema(input)) return "json-schema";
@@ -413,6 +837,7 @@ async function extractSchema(input, variant) {
 	const resolvedVariant = variant ?? extractResolvedVariant(input);
 	let schema;
 	if (resolvedVariant === "zod3" || resolvedVariant === "json-schema" || resolvedVariant === "standard-schema" || resolvedVariant === "untyped" || resolvedVariant === "valibot") schema = extractJsonSchema(input);
+	else if (resolvedVariant === "reflection") schema = extractReflection(input);
 	if (schema) return bundleReferences(schema);
 	throw new Error(`Failed to extract a valid schema from the provided input. The input must be a Zod schema, a Standard JSON Schema, a JSON Schema object, a Valibot BaseSchema, an untyped schema, or a reflected Deepkit Type object.`);
 }
@@ -450,123 +875,166 @@ function extractSource(variant, input) {
 		variant: "valibot",
 		schema: input
 	};
+	else if (variant === "reflection") return {
+		hash: extractHash(variant, input),
+		variant: "reflection",
+		schema: input
+	};
 	throw new Error(`Failed to extract source information from the provided input. The input must be a Zod schema, a Standard JSON Schema, a JSON Schema object, an untyped schema, or a reflected Deepkit Type object.`);
 }
-function getTsCompilerOptions(config) {
-	if (config.tsconfig) {
-		const raw = typescript.default.sys.readFile(config.tsconfig);
-		if (!raw) throw new Error(`Cannot read config file "${config.tsconfig}"`);
-		const parsedConfig = typescript.default.parseConfigFileTextToJson(config.tsconfig, raw);
-		if (parsedConfig.error) throw new Error(parsedConfig.error.messageText.toString());
-		if (!parsedConfig.config) throw new Error(`Invalid parsed config file "${config.tsconfig}"`);
-		const parseResult = typescript.default.parseJsonConfigFileContent(parsedConfig.config, typescript.default.sys, (0, _stryke_path_find.findFilePath)(config.tsconfig), {}, config.tsconfig);
-		parseResult.options.noEmit = true;
-		delete parseResult.options.out;
-		delete parseResult.options.outDir;
-		delete parseResult.options.outFile;
-		delete parseResult.options.declaration;
-		delete parseResult.options.declarationDir;
-		delete parseResult.options.declarationMap;
-		return parseResult.options;
-	}
+const deepkitCache = new _deepkit_type_compiler.Cache();
+function rewriteTypeOnlyImports(source) {
+	return source.replaceAll(/\bimport\s+type\s+/g, "import ").replaceAll(/\bexport\s+type\s+\*\s+from/g, "export * from").replaceAll(/\bexport\s+type\s+\{/g, "export {");
+}
+function resolveReflectionConfig(options) {
+	return {
+		reflection: options.reflection ?? "default",
+		exclude: options.exclude
+	};
+}
+function getCompilerOptions(options) {
+	const cwd = options.cwd || process.cwd();
+	const tsconfigPath = options.tsconfig ? (0, _stryke_path_append.appendPath)(options.tsconfig, cwd) : (0, _stryke_path_join.joinPaths)(cwd, "tsconfig.json");
+	try {
+		const raw = typescript.default.sys.readFile(tsconfigPath);
+		if (raw) {
+			const parsed = typescript.default.parseConfigFileTextToJson(tsconfigPath, raw);
+			if (parsed.config) return {
+				...typescript.default.parseJsonConfigFileContent(parsed.config, typescript.default.sys, (0, _stryke_path_find.findFilePath)(tsconfigPath) || cwd, {}, tsconfigPath).options,
+				noEmit: true,
+				experimentalDecorators: true,
+				emitDecoratorMetadata: true
+			};
+		}
+	} catch {}
 	return {
-		noEmit: true,
-		emitDecoratorMetadata: true,
-		experimentalDecorators: true,
 		target: typescript.default.ScriptTarget.ES2022,
 		module: typescript.default.ModuleKind.ESNext,
 		moduleResolution: typescript.default.ModuleResolutionKind.Bundler,
-		strictNullChecks: false,
+		strictNullChecks: true,
+		experimentalDecorators: true,
+		emitDecoratorMetadata: true,
 		skipLibCheck: true,
-		skipDefaultLibCheck: true,
 		esModuleInterop: true,
-		types: ["node"]
+		noEmit: true
 	};
 }
-function getScriptKind(fileName) {
-	switch ((0, _stryke_path_find.findFileExtensionSafe)(fileName)?.toLowerCase()) {
-		case "tsx": return typescript.default.ScriptKind.TSX;
-		case "jsx": return typescript.default.ScriptKind.JSX;
-		case "js":
-		case "cjs":
-		case "mjs": return typescript.default.ScriptKind.JS;
-		default: return typescript.default.ScriptKind.TS;
+function transpileWithDeepkit(code, fileName, options) {
+	const reflectionConfig = resolveReflectionConfig(options);
+	deepkitCache.tick();
+	return typescript.default.transpileModule(code, {
+		compilerOptions: getCompilerOptions(options),
+		fileName,
+		transformers: {
+			before: [(context) => new _deepkit_type_compiler.ReflectionTransformer(context, deepkitCache).withReflection(reflectionConfig)],
+			after: [(context) => new _deepkit_type_compiler.DeclarationTransformer(context, deepkitCache).withReflection(reflectionConfig)]
+		}
+	});
+}
+async function readSourceFile(path, fs) {
+	try {
+		if (fs?.promises?.readFile) return await fs.promises.readFile(path, "utf8");
+		return await (0, node_fs_promises.readFile)(path, "utf8");
+	} catch {
+		return;
 	}
 }
-/**
-* Builds a TypeScript program from original sources collected during the
-* esbuild graph walk so type information remains intact for schema generation.
-*/
-function createProgramFromSources(filePath, source, config) {
-	const compilerOptions = getTsCompilerOptions(config);
-	const host = typescript.default.createCompilerHost(compilerOptions, true);
-	const baseFileExists = host.fileExists.bind(host);
-	const baseReadFile = host.readFile.bind(host);
-	const baseGetSourceFile = host.getSourceFile.bind(host);
-	host.fileExists = (name) => filePath === name || baseFileExists(name);
-	host.readFile = (name) => filePath === name ? source : baseReadFile(name);
-	host.getSourceFile = (name, languageVersionOrOptions, onError, shouldCreateNewSourceFile) => {
-		if (filePath === name) {
-			const scriptTarget = typeof languageVersionOrOptions === "object" ? languageVersionOrOptions.languageVersion : languageVersionOrOptions;
-			return typescript.default.createSourceFile(name, source, scriptTarget ?? compilerOptions.target ?? typescript.default.ScriptTarget.ES2022, true, getScriptKind(name));
+function createDeepkitPlugin(options) {
+	return {
+		name: "power-plant:deepkit",
+		setup(pluginBuild) {
+			pluginBuild.onLoad({ filter: /\.(m|c)?tsx?$/ }, async (args) => {
+				if (args.pluginData?.isReflected) {
+					const contents = await readSourceFile(args.path, options.fs);
+					if (!contents) return null;
+					return {
+						contents,
+						loader: "ts",
+						pluginData: { isReflected: true }
+					};
+				}
+				const raw = await readSourceFile(args.path, options.fs);
+				if (!raw) return null;
+				const result = transpileWithDeepkit(rewriteTypeOnlyImports(raw), args.path, options);
+				if (result.diagnostics?.length) {
+					const errors = result.diagnostics.filter((diagnostic) => diagnostic.category === typescript.DiagnosticCategory.Error);
+					if (errors.length > 0) {
+						const errorMessage = `Deepkit Type reflection transpilation errors: ${args.path} \n ${errors.map((diagnostic) => `-${diagnostic.file ? `${diagnostic.file.fileName}:` : ""} ${typeof diagnostic.messageText === "string" ? diagnostic.messageText : diagnostic.messageText.messageText} (at ${diagnostic.start}:${diagnostic.length})`).join("\n")}`;
+						options.logger?.error?.(errorMessage);
+						throw new Error(errorMessage);
+					}
+				}
+				return {
+					contents: result.outputText,
+					loader: "ts",
+					pluginData: { isReflected: true }
+				};
+			});
 		}
-		return baseGetSourceFile(name, languageVersionOrOptions, onError, shouldCreateNewSourceFile);
 	};
-	const program = typescript.default.createProgram([filePath], compilerOptions, host);
-	if (!config.skipTypeCheck) {
-		const diagnostics = typescript.default.getPreEmitDiagnostics(program);
-		if (diagnostics.length) throw new Error(`Type check error: ${diagnostics.map((diagnostic) => diagnostic.messageText.toString()).join("\n")}`);
-	}
-	return program;
 }
 /**
-* Resolves a type definition to a JSON Schema. First bundles the TypeScript
-* module graph for {@link FileReference.file} with esbuild (preserving original
-* sources), then feeds that program to
-* [ts-json-schema-generator](https://github.com/vega/ts-json-schema-generator)
-* using the referenced export name as the target type when one is provided.
+* Resolves a type definition to a JSON Schema. Bundles the TypeScript module
+* graph with esbuild using `@deepkit/type-compiler` reflection transformers,
+* then converts the reflected Deepkit {@link Type} via {@link reflectionToJsonSchema}.
 *
 * @param input - The type definition to compile. This can be either a string or a {@link FileReference} object.
-* @param options - Optional overrides reserved for API compatibility.
+* @param options - Optional overrides for reflection and file resolution.
 * @returns A promise that resolves to the generated JSON Schema.
+* @see https://deepkit.io/en/documentation/runtime-types/reflection
 */
 async function extractTSType(input, options = {}) {
 	const fileReference = (0, _stryke_convert_extract_file_reference.extractFileReference)(input);
 	if (!fileReference) throw new Error(`Failed to extract a file reference from the provided input. The input must be a string or an object with a "file" property that specifies the file path and optional export name.`);
-	const exportName = fileReference.export ?? "*";
+	const exportName = fileReference.export ?? "default";
 	const resolvedPath = await (0, _stryke_fs_resolve.resolveSafe)(fileReference.file, { fs: options.fs });
 	const filePath = resolvedPath || fileReference.file;
+	const cwd = options.cwd || process.cwd();
 	try {
-		const tsconfig = options.tsconfig ? (0, _stryke_path_append.appendPath)(options.tsconfig, options.cwd || process.cwd()) : (0, _stryke_path_join.joinPaths)(options.cwd || process.cwd(), "tsconfig.json");
-		const bundled = await (0, _stryke_resolve_resolve.resolve)(filePath, {
-			cwd: options.cwd || process.cwd(),
-			fs: options.fs
-		});
 		options.logger?.debug?.(`Generating JSON schema for bundled "${filePath}" using the type "${exportName}"`);
-		const config = {
-			...ts_json_schema_generator_dist_src_Config_js.DEFAULT_CONFIG,
-			expose: "all",
-			jsDoc: "extended",
-			markdownDescription: true,
-			fullDescription: true,
-			...options,
-			tsconfig,
-			path: filePath,
-			type: exportName,
-			skipTypeCheck: true,
-			functions: "schema"
-		};
-		const tsProgram = createProgramFromSources(filePath, bundled, config);
-		return (0, ts_json_schema_generator_dist_factory_generator_js.createGenerator)({
-			...config,
-			tsProgram
-		}).createSchema(exportName);
+		const result = await (0, esbuild.build)({
+			platform: "node",
+			format: "esm",
+			logLevel: "silent",
+			entryPoints: [filePath],
+			write: false,
+			sourcemap: false,
+			splitting: false,
+			treeShaking: true,
+			bundle: true,
+			packages: "bundle",
+			keepNames: true,
+			metafile: false,
+			absWorkingDir: cwd,
+			plugins: [createDeepkitPlugin(options)]
+		});
+		if (result.errors.length > 0) throw new Error(result.errors.map((error) => error.text).join(", "));
+		const bundled = result.outputFiles?.filter(Boolean)[0]?.text;
+		if (!(0, _stryke_type_checks.isSetString)(bundled)) throw new Error(`No output files generated for "${filePath}". Please check the configuration and try again.`);
+		const evaluated = await (0, jiti.createJiti)(cwd).evalModule(bundled, {
+			filename: filePath,
+			ext: (0, _stryke_path_find.findFileDotExtensionSafe)(filePath) || ".ts"
+		});
+		let resolved = evaluated[exportName] ?? evaluated[`__Ω${exportName}`];
+		if (resolved === void 0) throw new Error(`The export "${exportName}" could not be resolved in the "${filePath}" module. ${Object.keys(evaluated).length === 0 ? `After bundling, no exports were found in the module.` : `After bundling, the available exports were: ${Object.keys(evaluated).join(", ")}.`}`);
+		try {
+			const type = (0, _deepkit_type.reflect)(resolved);
+			if ((0, _deepkit_type.isType)(type)) resolved = type;
+		} catch {}
+		if ((0, _deepkit_type.isType)(resolved)) {
+			const schema = extractReflection(resolved);
+			if (!schema) throw new Error(`Failed to convert the reflected Deepkit type for "${exportName}" to JSON Schema.`);
+			return schema;
+		}
+		const schema = extractJsonSchema(resolved);
+		if (!schema) throw new Error(`The export "${exportName}" could not be converted to a JSON Schema.`);
+		return schema;
 	} catch (error) {
 		throw new Error(`Failed to generate a JSON schema for "${fileReference.file}"${resolvedPath && resolvedPath !== fileReference.file ? ` (resolved: ${resolvedPath})` : ""} using the type "${exportName}". Error: ${error.message}`);
 	}
 }
 /**
-* Extracts a JSON Schema from a given schema definition input, which can be a Zod schema, a Valibot schema, any Standard JSON Schema type, a plain JSON Schema object, an untyped schema, or a {@link FileReferenceInput} to an exported TypeScript type definition or any of the previous options. If the input is a {@link FileReferenceInput} (e.g. a file path with an export), the source code will be bundled with [esbuild](esbuild.github.io) using [ts-json-schema-generator](https://github.com/vega/ts-json-schema-generator) to obtain the actual schema definition before extraction.
+* Extracts a JSON Schema from a given schema definition input, which can be a Zod schema, a Valibot schema, any Standard JSON Schema type, a plain JSON Schema object, an untyped schema, a Deepkit Type object, or a {@link FileReferenceInput} to an exported TypeScript type definition or any of the previous options. If the input is a {@link FileReferenceInput} (e.g. a file path with an export), the source code will be bundled with [esbuild](https://esbuild.github.io) using [@deepkit/type-compiler](https://deepkit.io/en/documentation/runtime-types/getting-started) reflection to obtain the actual schema definition before extraction.
 *
 * @example
 * ```ts
@@ -580,8 +1048,8 @@ async function extractTSType(input, options = {}) {
 * const schema4 = await extract(context, zodSchema);
 * // Resolve a schema definition from a Valibot schema
 * const schema5 = await extract(context, valibotSchema);
-* // Resolve a schema definition from an untyped schema
-* const schema6 = await extract(context, untypedSchema);
+* // Resolve a schema definition from a reflected Deepkit Type object
+* const schema6 = await extract(context, reflectionType);
 * ```
 *
 * @see https://zod.dev/
@@ -589,7 +1057,7 @@ async function extractTSType(input, options = {}) {
 * @see https://standardschema.dev/json-schema#what-schema-libraries-support-this-spec
 * @see https://json-schema.org/
 * @see https://ajv.js.org/json-type-definition.html
-* @see https://github.com/vega/ts-json-schema-generator
+* @see https://deepkit.io/en/documentation/runtime-types/reflection
 * @see https://github.com/unjs/untyped
 * @see https://www.typescriptlang.org/docs/handbook/2/types-from-types.html
 *
@@ -620,13 +1088,22 @@ async function extractSchemaWithSource(input, options = {}) {
 		let fs;
 		if (options.storage) fs = require_storage.mapStorageToFileSystem(options.storage);
 		let resolved = await (0, _stryke_resolve_load.loadSafe)(unwrappedConfig, {
-			...options,
-			fs
+			...(0, _stryke_helpers_omit.omit)(options, [
+				"storage",
+				"logger",
+				"tsconfig"
+			]),
+			fs,
+			cwd: options.cwd ?? void 0
 		});
 		resolved ??= await extractTSType(unwrappedConfig, {
 			...options,
 			fs
 		});
+		try {
+			const type = (0, _deepkit_type.reflect)(resolved);
+			if ((0, _deepkit_type.isType)(type)) resolved = type;
+		} catch {}
 		const resolvedConfig = unwrapSchemaConfig(resolved);
 		if (require_helpers.isSchemaWithSource(resolvedConfig)) source = resolvedConfig.source;
 		else if (require_helpers.isSchema(resolvedConfig)) source = {
@@ -652,7 +1129,7 @@ async function extractSchemaWithSource(input, options = {}) {
 	};
 }
 /**
-* Extracts a JSON Schema from a given schema definition input, which can be a Zod schema, a Valibot schema, any Standard JSON Schema type, a plain JSON Schema object, an untyped schema, or a {@link FileReferenceInput} to an exported TypeScript type definition or any of the previous options. If the input is a {@link FileReferenceInput} (e.g. a file path with an export), the source code will be bundled with [esbuild](esbuild.github.io) using [ts-json-schema-generator](https://github.com/vega/ts-json-schema-generator) to obtain the actual schema definition before extraction.
+* Extracts a JSON Schema from a given schema definition input, which can be a Zod schema, a Valibot schema, any Standard JSON Schema type, a plain JSON Schema object, an untyped schema, a Deepkit Type object, or a {@link FileReferenceInput} to an exported TypeScript type definition or any of the previous options. If the input is a {@link FileReferenceInput} (e.g. a file path with an export), the source code will be bundled with [esbuild](https://esbuild.github.io) using [@deepkit/type-compiler](https://deepkit.io/en/documentation/runtime-types/getting-started) reflection to obtain the actual schema definition before extraction.
 *
 * @example
 * ```ts
@@ -666,8 +1143,8 @@ async function extractSchemaWithSource(input, options = {}) {
 * const schema4 = await extract(context, zodSchema);
 * // Resolve a schema definition from a Valibot schema
 * const schema5 = await extract(context, valibotSchema);
-* // Resolve a schema definition from an untyped schema
-* const schema6 = await extract(context, untypedSchema);
+* // Resolve a schema definition from a reflected Deepkit Type object
+* const schema6 = await extract(context, reflectionType);
 * ```
 *
 * @see https://zod.dev/
@@ -675,7 +1152,7 @@ async function extractSchemaWithSource(input, options = {}) {
 * @see https://standardschema.dev/json-schema#what-schema-libraries-support-this-spec
 * @see https://json-schema.org/
 * @see https://ajv.js.org/json-type-definition.html
-* @see https://github.com/vega/ts-json-schema-generator
+* @see https://deepkit.io/en/documentation/runtime-types/reflection
 * @see https://github.com/unjs/untyped
 * @see https://www.typescriptlang.org/docs/handbook/2/types-from-types.html
 *
@@ -709,6 +1186,7 @@ exports.createStoragePromises = require_storage.createStoragePromises;
 exports.extract = extract;
 exports.extractHash = extractHash;
 exports.extractJsonSchema = extractJsonSchema;
+exports.extractReflection = extractReflection;
 exports.extractResolvedVariant = extractResolvedVariant;
 exports.extractSchema = extractSchema;
 exports.extractSchemaWithSource = extractSchemaWithSource;