@power-plant/schema 0.0.34 → 0.0.35

package/dist/codegen.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_helpers = require('./helpers-sXsSapgI.cjs');
+const require_helpers = require('./helpers-BQD6GZyX.cjs');
 let _stryke_type_checks_is_set_string = require("@stryke/type-checks/is-set-string");
 let _stryke_type_checks = require("@stryke/type-checks");
 let _stryke_string_format_list = require("@stryke/string-format/list");

package/dist/codegen.d.mts

@@ -1,4 +1,4 @@
-import { U as JsonSchemaType, a as JsonSchema } from "./types-CjF4wIDK.mjs";
+import { U as JsonSchemaType, a as JsonSchema } from "./types-CyvYSCHO.mjs";
 //#region src/codegen.d.ts
 /**
  * Stringifies a value for generated TypeScript code.

package/dist/codegen.mjs

@@ -1,4 +1,4 @@
-import { E as isJsonSchemaLiteral, N as isJsonSchemaObject, a as getPropertiesList, c as isSchemaNullable, m as isJsonSchema, rt as getPrimarySchemaType, u as merge, z as isJsonSchemaString } from "./helpers-reqtcaa8.mjs";
+import { B as isJsonSchemaString, D as isJsonSchemaLiteral, P as isJsonSchemaObject, a as getPropertiesList, c as isSchemaNullable, d as merge, h as isJsonSchema, ot as getPrimarySchemaType } from "./helpers-dvxktFml.mjs";
 import { isSetString } from "@stryke/type-checks/is-set-string";
 import { isInteger, isObject, isSetArray, isString } from "@stryke/type-checks";
 import { list } from "@stryke/string-format/list";

package/dist/{helpers-sXsSapgI.cjs → helpers-BQD6GZyX.cjs}

@@ -189,7 +189,7 @@ function isJsonSchemaKeywords(input) {
 function isJsonSchemaAny(input) {
 	if (!(0, _stryke_type_checks.isSetObject)(input)) return false;
 	const schema = input;
-	return hasValidJsonSchemaKeywords(schema) && isOptionalString(schema.$ref) && (!schema.type || Array.isArray(schema.type) && schema.type.every((t) => require_constants.JSON_SCHEMA_PRIMITIVE_TYPES.includes(t)));
+	return hasValidJsonSchemaKeywords(schema) && isOptionalString(schema.$ref) && (!schema.type || (0, _stryke_type_checks.isSetString)(schema.type) && JSON_SCHEMA_PRIMITIVE_TYPE_SET.has(schema.type) || Array.isArray(schema.type) && schema.type.every((t) => require_constants.JSON_SCHEMA_PRIMITIVE_TYPES.includes(t)));
 }
 /**
 * Type guard for JSON Schema array types.
@@ -590,7 +590,8 @@ function isUntypedSchema(input) {
 * @returns True if the input is an untyped schema and not a JSON Schema.
 */
 function isUntypedSchemaStrict(input) {
-	return isUntypedSchema(input) && !isJsonSchema(input);
+	if (!isUntypedSchema(input) || isJsonSchema(input)) return false;
+	return !("type" in input);
 }
 /**
 * Type guard for untyped input objects.
@@ -601,6 +602,8 @@ function isUntypedSchemaStrict(input) {
 * @param input - The value to check.
 * @returns True if the input is an untyped input object, false otherwise.
 */
+/** @deprecated Use {@link isUntypedConfig} */
+const isUntypedInput = isUntypedConfig;
 function isUntypedConfig(input) {
 	if (!(0, _stryke_type_checks.isSetObject)(input)) return false;
 	const inputObject = input;
@@ -618,6 +621,8 @@ function isUntypedConfig(input) {
 * @param input - The value to check.
 * @returns True if the input is an untyped input object and not JSON Schema.
 */
+/** @deprecated Use {@link isUntypedConfigStrict} */
+const isUntypedInputStrict = isUntypedConfigStrict;
 function isUntypedConfigStrict(input) {
 	if (!isUntypedConfig(input) || isJsonSchema(input)) return false;
 	const inputObject = input;
@@ -876,6 +881,8 @@ function isPropertyOptional(parent, propertyName) {
 function isValidSchemaConfigFile(fileName) {
 	return _stryke_resolve_constants.VALID_OBJECT_SOURCE_EXTENSIONS.includes((0, _stryke_path_find.findFileExtensionSafe)(fileName));
 }
+/** @deprecated Use {@link isValidSchemaConfigFile} */
+const isValidSchemaInputFile = isValidSchemaConfigFile;
 /**
 * Traverses a JSON Schema and applies a callback function to each schema fragment.
 *
@@ -1219,6 +1226,18 @@ Object.defineProperty(exports, 'isUntypedConfigStrict', {
     return isUntypedConfigStrict;
   }
 });
+Object.defineProperty(exports, 'isUntypedInput', {
+  enumerable: true,
+  get: function () {
+    return isUntypedInput;
+  }
+});
+Object.defineProperty(exports, 'isUntypedInputStrict', {
+  enumerable: true,
+  get: function () {
+    return isUntypedInputStrict;
+  }
+});
 Object.defineProperty(exports, 'isUntypedSchema', {
   enumerable: true,
   get: function () {
@@ -1243,6 +1262,12 @@ Object.defineProperty(exports, 'isValidSchemaConfigFile', {
     return isValidSchemaConfigFile;
   }
 });
+Object.defineProperty(exports, 'isValidSchemaInputFile', {
+  enumerable: true,
+  get: function () {
+    return isValidSchemaInputFile;
+  }
+});
 Object.defineProperty(exports, 'merge', {
   enumerable: true,
   get: function () {

package/dist/{helpers-reqtcaa8.mjs → helpers-dvxktFml.mjs}

@@ -187,7 +187,7 @@ function isJsonSchemaKeywords(input) {
 function isJsonSchemaAny(input) {
 	if (!isSetObject$1(input)) return false;
 	const schema = input;
-	return hasValidJsonSchemaKeywords(schema) && isOptionalString(schema.$ref) && (!schema.type || Array.isArray(schema.type) && schema.type.every((t) => JSON_SCHEMA_PRIMITIVE_TYPES.includes(t)));
+	return hasValidJsonSchemaKeywords(schema) && isOptionalString(schema.$ref) && (!schema.type || isSetString$1(schema.type) && JSON_SCHEMA_PRIMITIVE_TYPE_SET.has(schema.type) || Array.isArray(schema.type) && schema.type.every((t) => JSON_SCHEMA_PRIMITIVE_TYPES.includes(t)));
 }
 /**
 * Type guard for JSON Schema array types.
@@ -588,7 +588,8 @@ function isUntypedSchema(input) {
 * @returns True if the input is an untyped schema and not a JSON Schema.
 */
 function isUntypedSchemaStrict(input) {
-	return isUntypedSchema(input) && !isJsonSchema(input);
+	if (!isUntypedSchema(input) || isJsonSchema(input)) return false;
+	return !("type" in input);
 }
 /**
 * Type guard for untyped input objects.
@@ -599,6 +600,8 @@ function isUntypedSchemaStrict(input) {
 * @param input - The value to check.
 * @returns True if the input is an untyped input object, false otherwise.
 */
+/** @deprecated Use {@link isUntypedConfig} */
+const isUntypedInput = isUntypedConfig;
 function isUntypedConfig(input) {
 	if (!isSetObject$1(input)) return false;
 	const inputObject = input;
@@ -616,6 +619,8 @@ function isUntypedConfig(input) {
 * @param input - The value to check.
 * @returns True if the input is an untyped input object and not JSON Schema.
 */
+/** @deprecated Use {@link isUntypedConfigStrict} */
+const isUntypedInputStrict = isUntypedConfigStrict;
 function isUntypedConfigStrict(input) {
 	if (!isUntypedConfig(input) || isJsonSchema(input)) return false;
 	const inputObject = input;
@@ -874,6 +879,8 @@ function isPropertyOptional(parent, propertyName) {
 function isValidSchemaConfigFile(fileName) {
 	return VALID_OBJECT_SOURCE_EXTENSIONS.includes(findFileExtensionSafe(fileName));
 }
+/** @deprecated Use {@link isValidSchemaConfigFile} */
+const isValidSchemaInputFile = isValidSchemaConfigFile;
 /**
 * Traverses a JSON Schema and applies a callback function to each schema fragment.
 *
@@ -917,5 +924,5 @@ function traverseSchema(schema, callback) {
 }
 
 //#endregion
-export { isUntypedSchema as $, isJsonSchemaNull as A, isJsonSchemaTuple as B, isJsonSchemaEnum as C, isJsonSchemaMap as D, isJsonSchemaLiteral as E, isJsonSchemaPrimitiveUnion as F, isNullOnlyJsonSchema as G, isJsonSchemaUndefined as H, isJsonSchemaRecord as I, isSchemaOf as J, isSchema as K, isJsonSchemaRef as L, isJsonSchemaNumber as M, isJsonSchemaObject as N, isJsonSchemaNativeEnum as O, isJsonSchemaPrimitiveType as P, isUntypedConfigStrict as Q, isJsonSchemaSet as R, isJsonSchemaDecimal as S, isJsonSchemaKeywords as T, isJsonSchemaUnion as U, isJsonSchemaType as V, isJsonSchemaUnknown as W, isStandardSchema as X, isSchemaWithSource as Y, isUntypedConfig as Z, isJsonSchemaAnyOf as _, getPropertiesList as a, isJsonSchemaBoolean as b, isSchemaNullable as c, mergeMetadata as d, isUntypedSchemaStrict as et, traverseSchema as f, isJsonSchemaAny as g, isJsonSchemaAllOf as h, getProperties as i, readSchemaTypes as it, isJsonSchemaNullable as j, isJsonSchemaNever as k, isValidSchemaConfigFile as l, isJsonSchema as m, getJsonSchema as n, applyJsonSchemaMetadata as nt, getProperty as o, isFileReference as p, isSchemaObject as q, getJsonSchemaObject as r, getPrimarySchemaType as rt, isPropertyOptional as s, addProperty as t, isValibotSchema as tt, merge as u, isJsonSchemaArray as v, isJsonSchemaInteger as w, isJsonSchemaDate as x, isJsonSchemaBigint as y, isJsonSchemaString as z };
-//# sourceMappingURL=helpers-reqtcaa8.mjs.map
+export { isUntypedConfigStrict as $, isJsonSchemaNever as A, isJsonSchemaString as B, isJsonSchemaDecimal as C, isJsonSchemaLiteral as D, isJsonSchemaKeywords as E, isJsonSchemaPrimitiveType as F, isJsonSchemaUnknown as G, isJsonSchemaType as H, isJsonSchemaPrimitiveUnion as I, isSchemaObject as J, isNullOnlyJsonSchema as K, isJsonSchemaRecord as L, isJsonSchemaNullable as M, isJsonSchemaNumber as N, isJsonSchemaMap as O, isJsonSchemaObject as P, isUntypedConfig as Q, isJsonSchemaRef as R, isJsonSchemaDate as S, isJsonSchemaInteger as T, isJsonSchemaUndefined as U, isJsonSchemaTuple as V, isJsonSchemaUnion as W, isSchemaWithSource as X, isSchemaOf as Y, isStandardSchema as Z, isJsonSchemaAny as _, getPropertiesList as a, applyJsonSchemaMetadata as at, isJsonSchemaBigint as b, isSchemaNullable as c, merge as d, isUntypedInput as et, mergeMetadata as f, isJsonSchemaAllOf as g, isJsonSchema as h, getProperties as i, isValibotSchema as it, isJsonSchemaNull as j, isJsonSchemaNativeEnum as k, isValidSchemaConfigFile as l, isFileReference as m, getJsonSchema as n, isUntypedSchema as nt, getProperty as o, getPrimarySchemaType as ot, traverseSchema as p, isSchema as q, getJsonSchemaObject as r, isUntypedSchemaStrict as rt, isPropertyOptional as s, readSchemaTypes as st, addProperty as t, isUntypedInputStrict as tt, isValidSchemaInputFile as u, isJsonSchemaAnyOf as v, isJsonSchemaEnum as w, isJsonSchemaBoolean as x, isJsonSchemaArray as y, isJsonSchemaSet as z };
+//# sourceMappingURL=helpers-dvxktFml.mjs.map

package/dist/helpers-dvxktFml.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers-dvxktFml.mjs","names":[],"sources":[],"mappings":""}

package/dist/index.cjs

@@ -1,6 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_rolldown_runtime = require('./rolldown-runtime-C_NdSu1c.cjs');
 const require_constants = require('./constants-B7xonHLD.cjs');
-const require_helpers = require('./helpers-sXsSapgI.cjs');
+const require_helpers = require('./helpers-BQD6GZyX.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");
@@ -13,12 +14,18 @@ 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_bundle = require("@stryke/resolve/bundle");
 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 esbuild = require("esbuild");
 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 typescript = require("typescript");
+typescript = require_rolldown_runtime.__toESM(typescript, 1);
 
 //#region src/compatibility.ts
 const METADATA_KEYS = /* @__PURE__ */ new Set([
@@ -125,6 +132,9 @@ function assertSchemasDoNotContradict(base, override, label = "schema") {
 //#endregion
 //#region src/extract.ts
 const SCHEMA_BUNDLE_BASE_URI = "https://power-plant.invalid/";
+function normalizePath(filePath) {
+	return filePath.replaceAll("\\", "/");
+}
 function isWrappedSchemaConfig(input) {
 	if (!(0, _stryke_type_checks_is_set_object.isSetObject)(input) || !("schema" in input)) return false;
 	if ("hash" in input || "variant" in input || "source" in input) return false;
@@ -447,8 +457,148 @@ function extractSource(variant, 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;
+	}
+	return {
+		noEmit: true,
+		emitDecoratorMetadata: true,
+		experimentalDecorators: true,
+		target: typescript.default.ScriptTarget.ES2022,
+		module: typescript.default.ModuleKind.ESNext,
+		moduleResolution: typescript.default.ModuleResolutionKind.Bundler,
+		strictNullChecks: false,
+		skipLibCheck: true,
+		skipDefaultLibCheck: true,
+		esModuleInterop: true,
+		types: ["node"]
+	};
+}
+/**
+* Rewrites type-only imports/exports so esbuild still walks them while
+* collecting the original TypeScript sources for schema generation.
+*/
+function rewriteTypeOnlyImports(source) {
+	return source.replace(/\bimport\s+type\s+/g, "import ").replace(/\bexport\s+type\s+\*\s+from/g, "export * from").replace(/\bexport\s+type\s+\{/g, "export {");
+}
+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;
+	}
+}
+/**
+* Uses esbuild (with `@stryke/resolve` path resolution) to walk the module
+* graph, capturing original TypeScript sources before types are erased.
+*/
+async function bundleTypeScriptSources(filePath, options) {
+	const cwd = options.cwd || process.cwd();
+	const sources = /* @__PURE__ */ new Map();
+	const result = await (0, esbuild.build)({
+		absWorkingDir: cwd,
+		entryPoints: [filePath],
+		bundle: true,
+		write: false,
+		platform: "node",
+		format: "esm",
+		logLevel: "silent",
+		packages: "external",
+		plugins: [{
+			name: "power-plant-capture-ts-sources",
+			setup(buildApi) {
+				buildApi.onLoad({ filter: /.*/ }, async (args) => {
+					if (/[/\\]node_modules[/\\]/.test(args.path)) return null;
+					try {
+						const original = await (0, _stryke_resolve_resolve.resolve)(args.path, {
+							skipBundle: true,
+							cwd,
+							fs: options.fs
+						});
+						sources.set(normalizePath(args.path), original);
+						const extension = (0, _stryke_path_find.findFileExtensionSafe)(args.path);
+						const loader = extension === "tsx" || extension === "jsx" ? extension : extension === "js" || extension === "cjs" || extension === "mjs" ? "js" : "ts";
+						return {
+							contents: rewriteTypeOnlyImports(original),
+							loader
+						};
+					} catch {
+						return null;
+					}
+				});
+			}
+		}, (0, _stryke_resolve_bundle.plugin)({
+			originalInput: filePath,
+			cwd,
+			fs: options.fs ?? {}
+		})]
+	});
+	if (result.errors.length > 0) throw new Error(`Failed to bundle TypeScript sources for "${filePath}": ${result.errors.map((error) => error.text).join(", ")}`);
+	if (sources.size === 0) {
+		const fallback = await (0, _stryke_resolve_resolve.resolve)(filePath, {
+			skipBundle: true,
+			cwd,
+			fs: options.fs
+		});
+		sources.set(normalizePath(filePath), fallback);
+	}
+	return {
+		entryFileName: filePath,
+		sources
+	};
+}
+/**
+* Builds a TypeScript program from original sources collected during the
+* esbuild graph walk so type information remains intact for schema generation.
+*/
+function createProgramFromSources(entryFileName, sources, config) {
+	const compilerOptions = getTsCompilerOptions(config);
+	const host = typescript.default.createCompilerHost(compilerOptions, true);
+	const normalizedSources = new Map([...sources.entries()].map(([key, value]) => [normalizePath(key), value]));
+	const getContent = (name) => normalizedSources.get(normalizePath(name)) ?? normalizedSources.get(name);
+	const baseFileExists = host.fileExists.bind(host);
+	const baseReadFile = host.readFile.bind(host);
+	const baseGetSourceFile = host.getSourceFile.bind(host);
+	host.fileExists = (name) => getContent(name) !== void 0 || baseFileExists(name);
+	host.readFile = (name) => getContent(name) ?? baseReadFile(name);
+	host.getSourceFile = (name, languageVersionOrOptions, onError, shouldCreateNewSourceFile) => {
+		const content = getContent(name);
+		if (content !== void 0) {
+			const scriptTarget = typeof languageVersionOrOptions === "object" ? languageVersionOrOptions.languageVersion : languageVersionOrOptions;
+			return typescript.default.createSourceFile(name, content, scriptTarget ?? compilerOptions.target ?? typescript.default.ScriptTarget.ES2022, true, getScriptKind(name));
+		}
+		return baseGetSourceFile(name, languageVersionOrOptions, onError, shouldCreateNewSourceFile);
+	};
+	const program = typescript.default.createProgram([entryFileName], 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. This function passes the provided file reference to 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. 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.
 *
 * @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.
@@ -461,19 +611,29 @@ async function extractTSType(input, options = {}) {
 	const resolvedPath = await (0, _stryke_fs_resolve.resolveSafe)(fileReference.file, { fs: options.fs });
 	const filePath = resolvedPath || fileReference.file;
 	try {
-		const generatorConfig = {
-			path: filePath,
-			type: exportName,
+		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 { entryFileName, sources } = await bundleTypeScriptSources(filePath, {
+			cwd: options.cwd || process.cwd(),
+			fs: options.fs
+		});
+		const config = {
+			...ts_json_schema_generator_dist_src_Config_js.DEFAULT_CONFIG,
 			expose: "all",
 			jsDoc: "extended",
 			markdownDescription: true,
 			fullDescription: true,
-			skipTypeCheck: true,
 			...options,
-			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")
+			tsconfig,
+			path: entryFileName,
+			type: exportName,
+			skipTypeCheck: true
 		};
-		console.log(`Generating JSON schema for "${filePath}" using the type "${exportName}" with the following configuration: ${JSON.stringify(generatorConfig, null, 2)}`);
-		return (0, ts_json_schema_generator_dist_factory_generator_js.createGenerator)(generatorConfig).createSchema(exportName);
+		const tsProgram = createProgramFromSources(entryFileName, sources, config);
+		options.logger?.debug?.(`Generating JSON schema for bundled "${filePath}" using the type "${exportName}" (${sources.size} source file(s))`);
+		return (0, ts_json_schema_generator_dist_factory_generator_js.createGenerator)({
+			...config,
+			tsProgram
+		}).createSchema(exportName);
 	} 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}`);
 	}
@@ -676,10 +836,13 @@ exports.isSchemaWithSource = require_helpers.isSchemaWithSource;
 exports.isStandardSchema = require_helpers.isStandardSchema;
 exports.isUntypedConfig = require_helpers.isUntypedConfig;
 exports.isUntypedConfigStrict = require_helpers.isUntypedConfigStrict;
+exports.isUntypedInput = require_helpers.isUntypedInput;
+exports.isUntypedInputStrict = require_helpers.isUntypedInputStrict;
 exports.isUntypedSchema = require_helpers.isUntypedSchema;
 exports.isUntypedSchemaStrict = require_helpers.isUntypedSchemaStrict;
 exports.isValibotSchema = require_helpers.isValibotSchema;
 exports.isValidSchemaConfigFile = require_helpers.isValidSchemaConfigFile;
+exports.isValidSchemaInputFile = require_helpers.isValidSchemaInputFile;
 exports.mapStorageToFileSystem = require_storage.mapStorageToFileSystem;
 exports.merge = require_helpers.merge;
 exports.mergeMetadata = require_helpers.mergeMetadata;

package/dist/index.d.cts

@@ -84,7 +84,11 @@ declare function extractSchema(input: SchemaSourceConfig, variant?: SchemaConfig
  */
 declare function extractSource(variant: SchemaSourceVariant, input: SchemaSourceConfig): SchemaSource;
 /**
- * Resolves a type definition to a JSON Schema. This function passes the provided file reference to 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. 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.
  *
  * @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.
@@ -289,6 +293,8 @@ declare function isPropertyOptional(parent: JsonSchemaObject, propertyName: stri
  * @returns `true` if the file name has a valid schema input extension, otherwise `false`.
  */
 declare function isValidSchemaConfigFile(fileName: string): boolean;
+/** @deprecated Use {@link isValidSchemaConfigFile} */
+declare const isValidSchemaInputFile: typeof isValidSchemaConfigFile;
 /**
  * Traverses a JSON Schema and applies a callback function to each schema fragment.
  *
@@ -610,6 +616,8 @@ declare function isUntypedSchemaStrict(input: unknown): input is Schema;
  * @param input - The value to check.
  * @returns True if the input is an untyped input object, false otherwise.
  */
+/** @deprecated Use {@link isUntypedConfig} */
+declare const isUntypedInput: typeof isUntypedConfig;
 declare function isUntypedConfig(input: unknown): input is InputObject;
 /**
  * Strict type guard for untyped input objects.
@@ -621,6 +629,8 @@ declare function isUntypedConfig(input: unknown): input is InputObject;
  * @param input - The value to check.
  * @returns True if the input is an untyped input object and not JSON Schema.
  */
+/** @deprecated Use {@link isUntypedConfigStrict} */
+declare const isUntypedInputStrict: typeof isUntypedConfigStrict;
 declare function isUntypedConfigStrict(input: unknown): input is InputObject;
 /**
  * Type guard for Powerlines Schema objects.
@@ -651,5 +661,5 @@ declare function isSchemaWithSource(input: unknown): input is ExtractedSchemaEnv
  */
 declare function isSchemaObject(input: unknown): input is SchemaEnvelope<JsonSchemaObject>;
 //#endregion
-export { type BaseExtractOptions, type BaseSchemaSource, type ExtractedSchemaEnvelope, GetPropertyResult, type InferExtractOptions, JSON_SCHEMA_METADATA_KEYS, JSON_SCHEMA_PRIMITIVE_TYPES, JSON_SCHEMA_TYPES, type JsonSchema, type JsonSchemaAllOf, type JsonSchemaAny, type JsonSchemaAnyOf, type JsonSchemaArray, type JsonSchemaBigint, type JsonSchemaBoolean, type JsonSchemaConditionalKeywords, type JsonSchemaDate, type JsonSchemaDecimal, type JsonSchemaDecimalFormat, type JsonSchemaEnum, type JsonSchemaInteger, type JsonSchemaIntegerFormat, type JsonSchemaKeywords, type JsonSchemaLike, type JsonSchemaLiteral, type JsonSchemaLogicKeywords, type JsonSchemaMap, type JsonSchemaMetadataKeywords, type JsonSchemaNativeEnum, type JsonSchemaNever, type JsonSchemaNull, type JsonSchemaNullable, type JsonSchemaNumber, type JsonSchemaNumberFormat, type JsonSchemaObject, type JsonSchemaOf, type JsonSchemaPrimitiveType, type JsonSchemaPrimitiveUnion, type JsonSchemaRecord, type JsonSchemaRecordPropertyNames, type JsonSchemaRef, type JsonSchemaSchemaSource, type JsonSchemaSet, type JsonSchemaString, type JsonSchemaStringFormat, type JsonSchemaTuple, type JsonSchemaType, JsonSchemaTypeNames, type JsonSchemaUndefined, type JsonSchemaUnion, type JsonSchemaUnknown, SCHEMA_ARRAY_CONCAT_KEYWORDS, SCHEMA_RECORD_KEYWORDS, SCHEMA_SINGLE_KEYWORDS, type SchemaConfig, type SchemaConfigVariant, type SchemaEnvelope, type SchemaEnvelopeOf, type SchemaSource, type SchemaSourceConfig, type SchemaSourceVariant, type SpecOf, type StandardSchemaSchemaSource, type UntypedConfigObject, type UntypedSchema, type UntypedSchemaSource, type ValibotSchema, type ValibotSchemaSource, type Zod3SchemaSource, addProperty, applyJsonSchemaMetadata, assertSchemasDoNotContradict, bundleReferences, createStoragePromises, extract, extractHash, extractJsonSchema, extractResolvedVariant, extractSchema, extractSchemaWithSource, extractSource, extractTSType, extractVariant, findSchemaContradictions, getJsonSchema, getJsonSchemaObject, getPrimarySchemaType, getProperties, getPropertiesList, getProperty, isFileReference, isJsonSchema, isJsonSchemaAllOf, isJsonSchemaAny, isJsonSchemaAnyOf, isJsonSchemaArray, isJsonSchemaBigint, isJsonSchemaBoolean, isJsonSchemaDate, isJsonSchemaDecimal, isJsonSchemaEnum, isJsonSchemaInteger, isJsonSchemaKeywords, isJsonSchemaLiteral, isJsonSchemaMap, isJsonSchemaNativeEnum, isJsonSchemaNever, isJsonSchemaNull, isJsonSchemaNullable, isJsonSchemaNumber, isJsonSchemaObject, isJsonSchemaPrimitiveType, isJsonSchemaPrimitiveUnion, isJsonSchemaRecord, isJsonSchemaRef, isJsonSchemaSet, isJsonSchemaString, isJsonSchemaTuple, isJsonSchemaType, isJsonSchemaUndefined, isJsonSchemaUnion, isJsonSchemaUnknown, isNullOnlyJsonSchema, isPropertyOptional, isSchema, isSchemaNullable, isSchemaObject, isSchemaOf, isSchemaWithSource, isStandardSchema, isUntypedConfig, isUntypedConfigStrict, isUntypedSchema, isUntypedSchemaStrict, isValibotSchema, isValidSchemaConfigFile, mapStorageToFileSystem, merge, mergeMetadata, normalizeKey, readSchemaTypes, traverseSchema };
+export { type BaseExtractOptions, type BaseSchemaSource, type ExtractedSchemaEnvelope, GetPropertyResult, type InferExtractOptions, JSON_SCHEMA_METADATA_KEYS, JSON_SCHEMA_PRIMITIVE_TYPES, JSON_SCHEMA_TYPES, type JsonSchema, type JsonSchemaAllOf, type JsonSchemaAny, type JsonSchemaAnyOf, type JsonSchemaArray, type JsonSchemaBigint, type JsonSchemaBoolean, type JsonSchemaConditionalKeywords, type JsonSchemaDate, type JsonSchemaDecimal, type JsonSchemaDecimalFormat, type JsonSchemaEnum, type JsonSchemaInteger, type JsonSchemaIntegerFormat, type JsonSchemaKeywords, type JsonSchemaLike, type JsonSchemaLiteral, type JsonSchemaLogicKeywords, type JsonSchemaMap, type JsonSchemaMetadataKeywords, type JsonSchemaNativeEnum, type JsonSchemaNever, type JsonSchemaNull, type JsonSchemaNullable, type JsonSchemaNumber, type JsonSchemaNumberFormat, type JsonSchemaObject, type JsonSchemaOf, type JsonSchemaPrimitiveType, type JsonSchemaPrimitiveUnion, type JsonSchemaRecord, type JsonSchemaRecordPropertyNames, type JsonSchemaRef, type JsonSchemaSchemaSource, type JsonSchemaSet, type JsonSchemaString, type JsonSchemaStringFormat, type JsonSchemaTuple, type JsonSchemaType, JsonSchemaTypeNames, type JsonSchemaUndefined, type JsonSchemaUnion, type JsonSchemaUnknown, SCHEMA_ARRAY_CONCAT_KEYWORDS, SCHEMA_RECORD_KEYWORDS, SCHEMA_SINGLE_KEYWORDS, type SchemaConfig, type SchemaConfigVariant, type SchemaEnvelope, type SchemaEnvelopeOf, type SchemaSource, type SchemaSourceConfig, type SchemaSourceVariant, type SpecOf, type StandardSchemaSchemaSource, type UntypedConfigObject, type UntypedSchema, type UntypedSchemaSource, type ValibotSchema, type ValibotSchemaSource, type Zod3SchemaSource, addProperty, applyJsonSchemaMetadata, assertSchemasDoNotContradict, bundleReferences, createStoragePromises, extract, extractHash, extractJsonSchema, extractResolvedVariant, extractSchema, extractSchemaWithSource, extractSource, extractTSType, extractVariant, findSchemaContradictions, getJsonSchema, getJsonSchemaObject, getPrimarySchemaType, getProperties, getPropertiesList, getProperty, isFileReference, isJsonSchema, isJsonSchemaAllOf, isJsonSchemaAny, isJsonSchemaAnyOf, isJsonSchemaArray, isJsonSchemaBigint, isJsonSchemaBoolean, isJsonSchemaDate, isJsonSchemaDecimal, isJsonSchemaEnum, isJsonSchemaInteger, isJsonSchemaKeywords, isJsonSchemaLiteral, isJsonSchemaMap, isJsonSchemaNativeEnum, isJsonSchemaNever, isJsonSchemaNull, isJsonSchemaNullable, isJsonSchemaNumber, isJsonSchemaObject, isJsonSchemaPrimitiveType, isJsonSchemaPrimitiveUnion, isJsonSchemaRecord, isJsonSchemaRef, isJsonSchemaSet, isJsonSchemaString, isJsonSchemaTuple, isJsonSchemaType, isJsonSchemaUndefined, isJsonSchemaUnion, isJsonSchemaUnknown, isNullOnlyJsonSchema, isPropertyOptional, isSchema, isSchemaNullable, isSchemaObject, isSchemaOf, isSchemaWithSource, isStandardSchema, isUntypedConfig, isUntypedConfigStrict, isUntypedInput, isUntypedInputStrict, isUntypedSchema, isUntypedSchemaStrict, isValibotSchema, isValidSchemaConfigFile, isValidSchemaInputFile, mapStorageToFileSystem, merge, mergeMetadata, normalizeKey, readSchemaTypes, traverseSchema };
 //# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../src/compatibility.ts","../src/extract.ts","../src/helpers.ts","../src/metadata.ts","../src/type-checks.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/compatibility.ts","../src/extract.ts","../src/helpers.ts","../src/metadata.ts","../src/type-checks.ts"],"mappings":"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"}

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { $ as SchemaSourceVariant, A as JsonSchemaNumberFormat, B as JsonSchemaString, C as JsonSchemaMap, D as JsonSchemaNull, E as JsonSchemaNever, F as JsonSchemaRecord, G as JsonSchemaUnion, H as JsonSchemaTuple, I as JsonSchemaRecordPropertyNames, J as SchemaConfigVariant, K as JsonSchemaUnknown, L as JsonSchemaRef, M as JsonSchemaOf, N as JsonSchemaPrimitiveType, O as JsonSchemaNullable, P as JsonSchemaPrimitiveUnion, Q as SchemaSourceConfig, R as JsonSchemaSchemaSource, S as JsonSchemaLogicKeywords, T as JsonSchemaNativeEnum, U as JsonSchemaType, V as JsonSchemaStringFormat, W as JsonSchemaUndefined, X as SchemaEnvelopeOf, Y as SchemaEnvelope, Z as SchemaSource, _ as JsonSchemaInteger, a as JsonSchema, at as ValibotSchema, b as JsonSchemaLike, c as JsonSchemaAnyOf, ct as JSON_SCHEMA_METADATA_KEYS, d as JsonSchemaBoolean, dt as JsonSchemaTypeNames, et as SpecOf, f as JsonSchemaConditionalKeywords, ft as SCHEMA_ARRAY_CONCAT_KEYWORDS, g as JsonSchemaEnum, h as JsonSchemaDecimalFormat, i as InferExtractOptions, it as UntypedSchemaSource, j as JsonSchemaObject, k as JsonSchemaNumber, l as JsonSchemaArray, lt as JSON_SCHEMA_PRIMITIVE_TYPES, m as JsonSchemaDecimal, mt as SCHEMA_SINGLE_KEYWORDS, n as BaseSchemaSource, nt as UntypedConfigObject, o as JsonSchemaAllOf, ot as ValibotSchemaSource, p as JsonSchemaDate, pt as SCHEMA_RECORD_KEYWORDS, q as SchemaConfig, r as ExtractedSchemaEnvelope, rt as UntypedSchema, s as JsonSchemaAny, st as Zod3SchemaSource, t as BaseExtractOptions, tt as StandardSchemaSchemaSource, u as JsonSchemaBigint, ut as JSON_SCHEMA_TYPES, v as JsonSchemaIntegerFormat, w as JsonSchemaMetadataKeywords, x as JsonSchemaLiteral, y as JsonSchemaKeywords, z as JsonSchemaSet } from "./types-CjF4wIDK.mjs";
+import { $ as SchemaSourceVariant, A as JsonSchemaNumberFormat, B as JsonSchemaString, C as JsonSchemaMap, D as JsonSchemaNull, E as JsonSchemaNever, F as JsonSchemaRecord, G as JsonSchemaUnion, H as JsonSchemaTuple, I as JsonSchemaRecordPropertyNames, J as SchemaConfigVariant, K as JsonSchemaUnknown, L as JsonSchemaRef, M as JsonSchemaOf, N as JsonSchemaPrimitiveType, O as JsonSchemaNullable, P as JsonSchemaPrimitiveUnion, Q as SchemaSourceConfig, R as JsonSchemaSchemaSource, S as JsonSchemaLogicKeywords, T as JsonSchemaNativeEnum, U as JsonSchemaType, V as JsonSchemaStringFormat, W as JsonSchemaUndefined, X as SchemaEnvelopeOf, Y as SchemaEnvelope, Z as SchemaSource, _ as JsonSchemaInteger, a as JsonSchema, at as ValibotSchema, b as JsonSchemaLike, c as JsonSchemaAnyOf, ct as JSON_SCHEMA_METADATA_KEYS, d as JsonSchemaBoolean, dt as JsonSchemaTypeNames, et as SpecOf, f as JsonSchemaConditionalKeywords, ft as SCHEMA_ARRAY_CONCAT_KEYWORDS, g as JsonSchemaEnum, h as JsonSchemaDecimalFormat, i as InferExtractOptions, it as UntypedSchemaSource, j as JsonSchemaObject, k as JsonSchemaNumber, l as JsonSchemaArray, lt as JSON_SCHEMA_PRIMITIVE_TYPES, m as JsonSchemaDecimal, mt as SCHEMA_SINGLE_KEYWORDS, n as BaseSchemaSource, nt as UntypedConfigObject, o as JsonSchemaAllOf, ot as ValibotSchemaSource, p as JsonSchemaDate, pt as SCHEMA_RECORD_KEYWORDS, q as SchemaConfig, r as ExtractedSchemaEnvelope, rt as UntypedSchema, s as JsonSchemaAny, st as Zod3SchemaSource, t as BaseExtractOptions, tt as StandardSchemaSchemaSource, u as JsonSchemaBigint, ut as JSON_SCHEMA_TYPES, v as JsonSchemaIntegerFormat, w as JsonSchemaMetadataKeywords, x as JsonSchemaLiteral, y as JsonSchemaKeywords, z as JsonSchemaSet } from "./types-CyvYSCHO.mjs";
 import { n as createStoragePromises, r as normalizeKey, t as mapStorageToFileSystem } from "./index-C7q4X7Bo.mjs";
 import { BaseSchema } from "valibot";
 import { StandardSchemaV1 } from "@standard-schema/spec";
@@ -84,7 +84,11 @@ declare function extractSchema(input: SchemaSourceConfig, variant?: SchemaConfig
  */
 declare function extractSource(variant: SchemaSourceVariant, input: SchemaSourceConfig): SchemaSource;
 /**
- * Resolves a type definition to a JSON Schema. This function passes the provided file reference to 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. 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.
  *
  * @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.
@@ -289,6 +293,8 @@ declare function isPropertyOptional(parent: JsonSchemaObject, propertyName: stri
  * @returns `true` if the file name has a valid schema input extension, otherwise `false`.
  */
 declare function isValidSchemaConfigFile(fileName: string): boolean;
+/** @deprecated Use {@link isValidSchemaConfigFile} */
+declare const isValidSchemaInputFile: typeof isValidSchemaConfigFile;
 /**
  * Traverses a JSON Schema and applies a callback function to each schema fragment.
  *
@@ -610,6 +616,8 @@ declare function isUntypedSchemaStrict(input: unknown): input is Schema;
  * @param input - The value to check.
  * @returns True if the input is an untyped input object, false otherwise.
  */
+/** @deprecated Use {@link isUntypedConfig} */
+declare const isUntypedInput: typeof isUntypedConfig;
 declare function isUntypedConfig(input: unknown): input is InputObject;
 /**
  * Strict type guard for untyped input objects.
@@ -621,6 +629,8 @@ declare function isUntypedConfig(input: unknown): input is InputObject;
  * @param input - The value to check.
  * @returns True if the input is an untyped input object and not JSON Schema.
  */
+/** @deprecated Use {@link isUntypedConfigStrict} */
+declare const isUntypedInputStrict: typeof isUntypedConfigStrict;
 declare function isUntypedConfigStrict(input: unknown): input is InputObject;
 /**
  * Type guard for Powerlines Schema objects.
@@ -651,5 +661,5 @@ declare function isSchemaWithSource(input: unknown): input is ExtractedSchemaEnv
  */
 declare function isSchemaObject(input: unknown): input is SchemaEnvelope<JsonSchemaObject>;
 //#endregion
-export { type BaseExtractOptions, type BaseSchemaSource, type ExtractedSchemaEnvelope, GetPropertyResult, type InferExtractOptions, JSON_SCHEMA_METADATA_KEYS, JSON_SCHEMA_PRIMITIVE_TYPES, JSON_SCHEMA_TYPES, type JsonSchema, type JsonSchemaAllOf, type JsonSchemaAny, type JsonSchemaAnyOf, type JsonSchemaArray, type JsonSchemaBigint, type JsonSchemaBoolean, type JsonSchemaConditionalKeywords, type JsonSchemaDate, type JsonSchemaDecimal, type JsonSchemaDecimalFormat, type JsonSchemaEnum, type JsonSchemaInteger, type JsonSchemaIntegerFormat, type JsonSchemaKeywords, type JsonSchemaLike, type JsonSchemaLiteral, type JsonSchemaLogicKeywords, type JsonSchemaMap, type JsonSchemaMetadataKeywords, type JsonSchemaNativeEnum, type JsonSchemaNever, type JsonSchemaNull, type JsonSchemaNullable, type JsonSchemaNumber, type JsonSchemaNumberFormat, type JsonSchemaObject, type JsonSchemaOf, type JsonSchemaPrimitiveType, type JsonSchemaPrimitiveUnion, type JsonSchemaRecord, type JsonSchemaRecordPropertyNames, type JsonSchemaRef, type JsonSchemaSchemaSource, type JsonSchemaSet, type JsonSchemaString, type JsonSchemaStringFormat, type JsonSchemaTuple, type JsonSchemaType, JsonSchemaTypeNames, type JsonSchemaUndefined, type JsonSchemaUnion, type JsonSchemaUnknown, SCHEMA_ARRAY_CONCAT_KEYWORDS, SCHEMA_RECORD_KEYWORDS, SCHEMA_SINGLE_KEYWORDS, type SchemaConfig, type SchemaConfigVariant, type SchemaEnvelope, type SchemaEnvelopeOf, type SchemaSource, type SchemaSourceConfig, type SchemaSourceVariant, type SpecOf, type StandardSchemaSchemaSource, type UntypedConfigObject, type UntypedSchema, type UntypedSchemaSource, type ValibotSchema, type ValibotSchemaSource, type Zod3SchemaSource, addProperty, applyJsonSchemaMetadata, assertSchemasDoNotContradict, bundleReferences, createStoragePromises, extract, extractHash, extractJsonSchema, extractResolvedVariant, extractSchema, extractSchemaWithSource, extractSource, extractTSType, extractVariant, findSchemaContradictions, getJsonSchema, getJsonSchemaObject, getPrimarySchemaType, getProperties, getPropertiesList, getProperty, isFileReference, isJsonSchema, isJsonSchemaAllOf, isJsonSchemaAny, isJsonSchemaAnyOf, isJsonSchemaArray, isJsonSchemaBigint, isJsonSchemaBoolean, isJsonSchemaDate, isJsonSchemaDecimal, isJsonSchemaEnum, isJsonSchemaInteger, isJsonSchemaKeywords, isJsonSchemaLiteral, isJsonSchemaMap, isJsonSchemaNativeEnum, isJsonSchemaNever, isJsonSchemaNull, isJsonSchemaNullable, isJsonSchemaNumber, isJsonSchemaObject, isJsonSchemaPrimitiveType, isJsonSchemaPrimitiveUnion, isJsonSchemaRecord, isJsonSchemaRef, isJsonSchemaSet, isJsonSchemaString, isJsonSchemaTuple, isJsonSchemaType, isJsonSchemaUndefined, isJsonSchemaUnion, isJsonSchemaUnknown, isNullOnlyJsonSchema, isPropertyOptional, isSchema, isSchemaNullable, isSchemaObject, isSchemaOf, isSchemaWithSource, isStandardSchema, isUntypedConfig, isUntypedConfigStrict, isUntypedSchema, isUntypedSchemaStrict, isValibotSchema, isValidSchemaConfigFile, mapStorageToFileSystem, merge, mergeMetadata, normalizeKey, readSchemaTypes, traverseSchema };
+export { type BaseExtractOptions, type BaseSchemaSource, type ExtractedSchemaEnvelope, GetPropertyResult, type InferExtractOptions, JSON_SCHEMA_METADATA_KEYS, JSON_SCHEMA_PRIMITIVE_TYPES, JSON_SCHEMA_TYPES, type JsonSchema, type JsonSchemaAllOf, type JsonSchemaAny, type JsonSchemaAnyOf, type JsonSchemaArray, type JsonSchemaBigint, type JsonSchemaBoolean, type JsonSchemaConditionalKeywords, type JsonSchemaDate, type JsonSchemaDecimal, type JsonSchemaDecimalFormat, type JsonSchemaEnum, type JsonSchemaInteger, type JsonSchemaIntegerFormat, type JsonSchemaKeywords, type JsonSchemaLike, type JsonSchemaLiteral, type JsonSchemaLogicKeywords, type JsonSchemaMap, type JsonSchemaMetadataKeywords, type JsonSchemaNativeEnum, type JsonSchemaNever, type JsonSchemaNull, type JsonSchemaNullable, type JsonSchemaNumber, type JsonSchemaNumberFormat, type JsonSchemaObject, type JsonSchemaOf, type JsonSchemaPrimitiveType, type JsonSchemaPrimitiveUnion, type JsonSchemaRecord, type JsonSchemaRecordPropertyNames, type JsonSchemaRef, type JsonSchemaSchemaSource, type JsonSchemaSet, type JsonSchemaString, type JsonSchemaStringFormat, type JsonSchemaTuple, type JsonSchemaType, JsonSchemaTypeNames, type JsonSchemaUndefined, type JsonSchemaUnion, type JsonSchemaUnknown, SCHEMA_ARRAY_CONCAT_KEYWORDS, SCHEMA_RECORD_KEYWORDS, SCHEMA_SINGLE_KEYWORDS, type SchemaConfig, type SchemaConfigVariant, type SchemaEnvelope, type SchemaEnvelopeOf, type SchemaSource, type SchemaSourceConfig, type SchemaSourceVariant, type SpecOf, type StandardSchemaSchemaSource, type UntypedConfigObject, type UntypedSchema, type UntypedSchemaSource, type ValibotSchema, type ValibotSchemaSource, type Zod3SchemaSource, addProperty, applyJsonSchemaMetadata, assertSchemasDoNotContradict, bundleReferences, createStoragePromises, extract, extractHash, extractJsonSchema, extractResolvedVariant, extractSchema, extractSchemaWithSource, extractSource, extractTSType, extractVariant, findSchemaContradictions, getJsonSchema, getJsonSchemaObject, getPrimarySchemaType, getProperties, getPropertiesList, getProperty, isFileReference, isJsonSchema, isJsonSchemaAllOf, isJsonSchemaAny, isJsonSchemaAnyOf, isJsonSchemaArray, isJsonSchemaBigint, isJsonSchemaBoolean, isJsonSchemaDate, isJsonSchemaDecimal, isJsonSchemaEnum, isJsonSchemaInteger, isJsonSchemaKeywords, isJsonSchemaLiteral, isJsonSchemaMap, isJsonSchemaNativeEnum, isJsonSchemaNever, isJsonSchemaNull, isJsonSchemaNullable, isJsonSchemaNumber, isJsonSchemaObject, isJsonSchemaPrimitiveType, isJsonSchemaPrimitiveUnion, isJsonSchemaRecord, isJsonSchemaRef, isJsonSchemaSet, isJsonSchemaString, isJsonSchemaTuple, isJsonSchemaType, isJsonSchemaUndefined, isJsonSchemaUnion, isJsonSchemaUnknown, isNullOnlyJsonSchema, isPropertyOptional, isSchema, isSchemaNullable, isSchemaObject, isSchemaOf, isSchemaWithSource, isStandardSchema, isUntypedConfig, isUntypedConfigStrict, isUntypedInput, isUntypedInputStrict, isUntypedSchema, isUntypedSchemaStrict, isValibotSchema, isValidSchemaConfigFile, isValidSchemaInputFile, mapStorageToFileSystem, merge, mergeMetadata, normalizeKey, readSchemaTypes, traverseSchema };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import { a as SCHEMA_ARRAY_CONCAT_KEYWORDS, i as JsonSchemaTypeNames, n as JSON_SCHEMA_PRIMITIVE_TYPES, o as SCHEMA_RECORD_KEYWORDS, r as JSON_SCHEMA_TYPES, s as SCHEMA_SINGLE_KEYWORDS, t as JSON_SCHEMA_METADATA_KEYS } from "./constants-COGt3eeW.mjs";
-import { $ as isUntypedSchema, A as isJsonSchemaNull, B as isJsonSchemaTuple, C as isJsonSchemaEnum, D as isJsonSchemaMap, E as isJsonSchemaLiteral, F as isJsonSchemaPrimitiveUnion, G as isNullOnlyJsonSchema, H as isJsonSchemaUndefined, I as isJsonSchemaRecord, J as isSchemaOf, K as isSchema, L as isJsonSchemaRef, M as isJsonSchemaNumber, N as isJsonSchemaObject, O as isJsonSchemaNativeEnum, P as isJsonSchemaPrimitiveType, Q as isUntypedConfigStrict, R as isJsonSchemaSet, S as isJsonSchemaDecimal, T as isJsonSchemaKeywords, U as isJsonSchemaUnion, V as isJsonSchemaType, W as isJsonSchemaUnknown, X as isStandardSchema, Y as isSchemaWithSource, Z as isUntypedConfig, _ as isJsonSchemaAnyOf, a as getPropertiesList, b as isJsonSchemaBoolean, c as isSchemaNullable, d as mergeMetadata, et as isUntypedSchemaStrict, f as traverseSchema, g as isJsonSchemaAny, h as isJsonSchemaAllOf, i as getProperties, it as readSchemaTypes, j as isJsonSchemaNullable, k as isJsonSchemaNever, l as isValidSchemaConfigFile, m as isJsonSchema, n as getJsonSchema, nt as applyJsonSchemaMetadata, o as getProperty, p as isFileReference, q as isSchemaObject, r as getJsonSchemaObject, rt as getPrimarySchemaType, s as isPropertyOptional, t as addProperty, tt as isValibotSchema, u as merge, v as isJsonSchemaArray, w as isJsonSchemaInteger, x as isJsonSchemaDate, y as isJsonSchemaBigint, z as isJsonSchemaString } from "./helpers-reqtcaa8.mjs";
+import { $ as isUntypedConfigStrict, A as isJsonSchemaNever, B as isJsonSchemaString, C as isJsonSchemaDecimal, D as isJsonSchemaLiteral, E as isJsonSchemaKeywords, F as isJsonSchemaPrimitiveType, G as isJsonSchemaUnknown, H as isJsonSchemaType, I as isJsonSchemaPrimitiveUnion, J as isSchemaObject, K as isNullOnlyJsonSchema, L as isJsonSchemaRecord, M as isJsonSchemaNullable, N as isJsonSchemaNumber, O as isJsonSchemaMap, P as isJsonSchemaObject, Q as isUntypedConfig, R as isJsonSchemaRef, S as isJsonSchemaDate, T as isJsonSchemaInteger, U as isJsonSchemaUndefined, V as isJsonSchemaTuple, W as isJsonSchemaUnion, X as isSchemaWithSource, Y as isSchemaOf, Z as isStandardSchema, _ as isJsonSchemaAny, a as getPropertiesList, at as applyJsonSchemaMetadata, b as isJsonSchemaBigint, c as isSchemaNullable, d as merge, et as isUntypedInput, f as mergeMetadata, g as isJsonSchemaAllOf, h as isJsonSchema, i as getProperties, it as isValibotSchema, j as isJsonSchemaNull, k as isJsonSchemaNativeEnum, l as isValidSchemaConfigFile, m as isFileReference, n as getJsonSchema, nt as isUntypedSchema, o as getProperty, ot as getPrimarySchemaType, p as traverseSchema, q as isSchema, r as getJsonSchemaObject, rt as isUntypedSchemaStrict, s as isPropertyOptional, st as readSchemaTypes, t as addProperty, tt as isUntypedInputStrict, u as isValidSchemaInputFile, v as isJsonSchemaAnyOf, w as isJsonSchemaEnum, x as isJsonSchemaBoolean, y as isJsonSchemaArray, z as isJsonSchemaSet } from "./helpers-dvxktFml.mjs";
 import { n as createStoragePromises, r as normalizeKey, t as mapStorageToFileSystem } from "./storage-C3BT2Xh-.mjs";
 import { isSetObject } from "@stryke/type-checks/is-set-object";
 import { isSetString } from "@stryke/type-checks/is-set-string";
@@ -10,14 +10,19 @@ import { murmurhash } from "@stryke/hash";
 import { deepClone } from "@stryke/helpers/deep-clone";
 import { isStandardJsonSchema } from "@stryke/json";
 import { appendPath } from "@stryke/path/append";
-import { findFileExtensionSafe } from "@stryke/path/find";
+import { findFileExtensionSafe, findFilePath } from "@stryke/path/find";
 import { joinPaths } from "@stryke/path/join";
+import { plugin } from "@stryke/resolve/bundle";
 import { VALID_OBJECT_SOURCE_EXTENSIONS } from "@stryke/resolve/constants";
 import { loadSafe } from "@stryke/resolve/load";
+import { resolve } from "@stryke/resolve/resolve";
 import { list } from "@stryke/string-format/list";
 import { extractJsonSchema as extractJsonSchema$1, isZod3Type } from "@stryke/zod";
 import { toJsonSchema } from "@valibot/to-json-schema";
+import { build } from "esbuild";
 import { createGenerator } from "ts-json-schema-generator/dist/factory/generator.js";
+import { DEFAULT_CONFIG } from "ts-json-schema-generator/dist/src/Config.js";
+import ts from "typescript";
 
 //#region src/compatibility.ts
 const METADATA_KEYS = /* @__PURE__ */ new Set([
@@ -124,6 +129,9 @@ function assertSchemasDoNotContradict(base, override, label = "schema") {
 //#endregion
 //#region src/extract.ts
 const SCHEMA_BUNDLE_BASE_URI = "https://power-plant.invalid/";
+function normalizePath(filePath) {
+	return filePath.replaceAll("\\", "/");
+}
 function isWrappedSchemaConfig(input) {
 	if (!isSetObject(input) || !("schema" in input)) return false;
 	if ("hash" in input || "variant" in input || "source" in input) return false;
@@ -446,8 +454,148 @@ function extractSource(variant, 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 = ts.sys.readFile(config.tsconfig);
+		if (!raw) throw new Error(`Cannot read config file "${config.tsconfig}"`);
+		const parsedConfig = ts.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 = ts.parseJsonConfigFileContent(parsedConfig.config, ts.sys, 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;
+	}
+	return {
+		noEmit: true,
+		emitDecoratorMetadata: true,
+		experimentalDecorators: true,
+		target: ts.ScriptTarget.ES2022,
+		module: ts.ModuleKind.ESNext,
+		moduleResolution: ts.ModuleResolutionKind.Bundler,
+		strictNullChecks: false,
+		skipLibCheck: true,
+		skipDefaultLibCheck: true,
+		esModuleInterop: true,
+		types: ["node"]
+	};
+}
+/**
+* Rewrites type-only imports/exports so esbuild still walks them while
+* collecting the original TypeScript sources for schema generation.
+*/
+function rewriteTypeOnlyImports(source) {
+	return source.replace(/\bimport\s+type\s+/g, "import ").replace(/\bexport\s+type\s+\*\s+from/g, "export * from").replace(/\bexport\s+type\s+\{/g, "export {");
+}
+function getScriptKind(fileName) {
+	switch (findFileExtensionSafe(fileName)?.toLowerCase()) {
+		case "tsx": return ts.ScriptKind.TSX;
+		case "jsx": return ts.ScriptKind.JSX;
+		case "js":
+		case "cjs":
+		case "mjs": return ts.ScriptKind.JS;
+		default: return ts.ScriptKind.TS;
+	}
+}
+/**
+* Uses esbuild (with `@stryke/resolve` path resolution) to walk the module
+* graph, capturing original TypeScript sources before types are erased.
+*/
+async function bundleTypeScriptSources(filePath, options) {
+	const cwd = options.cwd || process.cwd();
+	const sources = /* @__PURE__ */ new Map();
+	const result = await build({
+		absWorkingDir: cwd,
+		entryPoints: [filePath],
+		bundle: true,
+		write: false,
+		platform: "node",
+		format: "esm",
+		logLevel: "silent",
+		packages: "external",
+		plugins: [{
+			name: "power-plant-capture-ts-sources",
+			setup(buildApi) {
+				buildApi.onLoad({ filter: /.*/ }, async (args) => {
+					if (/[/\\]node_modules[/\\]/.test(args.path)) return null;
+					try {
+						const original = await resolve(args.path, {
+							skipBundle: true,
+							cwd,
+							fs: options.fs
+						});
+						sources.set(normalizePath(args.path), original);
+						const extension = findFileExtensionSafe(args.path);
+						const loader = extension === "tsx" || extension === "jsx" ? extension : extension === "js" || extension === "cjs" || extension === "mjs" ? "js" : "ts";
+						return {
+							contents: rewriteTypeOnlyImports(original),
+							loader
+						};
+					} catch {
+						return null;
+					}
+				});
+			}
+		}, plugin({
+			originalInput: filePath,
+			cwd,
+			fs: options.fs ?? {}
+		})]
+	});
+	if (result.errors.length > 0) throw new Error(`Failed to bundle TypeScript sources for "${filePath}": ${result.errors.map((error) => error.text).join(", ")}`);
+	if (sources.size === 0) {
+		const fallback = await resolve(filePath, {
+			skipBundle: true,
+			cwd,
+			fs: options.fs
+		});
+		sources.set(normalizePath(filePath), fallback);
+	}
+	return {
+		entryFileName: filePath,
+		sources
+	};
+}
+/**
+* Builds a TypeScript program from original sources collected during the
+* esbuild graph walk so type information remains intact for schema generation.
+*/
+function createProgramFromSources(entryFileName, sources, config) {
+	const compilerOptions = getTsCompilerOptions(config);
+	const host = ts.createCompilerHost(compilerOptions, true);
+	const normalizedSources = new Map([...sources.entries()].map(([key, value]) => [normalizePath(key), value]));
+	const getContent = (name) => normalizedSources.get(normalizePath(name)) ?? normalizedSources.get(name);
+	const baseFileExists = host.fileExists.bind(host);
+	const baseReadFile = host.readFile.bind(host);
+	const baseGetSourceFile = host.getSourceFile.bind(host);
+	host.fileExists = (name) => getContent(name) !== void 0 || baseFileExists(name);
+	host.readFile = (name) => getContent(name) ?? baseReadFile(name);
+	host.getSourceFile = (name, languageVersionOrOptions, onError, shouldCreateNewSourceFile) => {
+		const content = getContent(name);
+		if (content !== void 0) {
+			const scriptTarget = typeof languageVersionOrOptions === "object" ? languageVersionOrOptions.languageVersion : languageVersionOrOptions;
+			return ts.createSourceFile(name, content, scriptTarget ?? compilerOptions.target ?? ts.ScriptTarget.ES2022, true, getScriptKind(name));
+		}
+		return baseGetSourceFile(name, languageVersionOrOptions, onError, shouldCreateNewSourceFile);
+	};
+	const program = ts.createProgram([entryFileName], compilerOptions, host);
+	if (!config.skipTypeCheck) {
+		const diagnostics = ts.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. This function passes the provided file reference to 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. 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.
 *
 * @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.
@@ -460,19 +608,29 @@ async function extractTSType(input, options = {}) {
 	const resolvedPath = await resolveSafe(fileReference.file, { fs: options.fs });
 	const filePath = resolvedPath || fileReference.file;
 	try {
-		const generatorConfig = {
-			path: filePath,
-			type: exportName,
+		const tsconfig = options.tsconfig ? appendPath(options.tsconfig, options.cwd || process.cwd()) : joinPaths(options.cwd || process.cwd(), "tsconfig.json");
+		const { entryFileName, sources } = await bundleTypeScriptSources(filePath, {
+			cwd: options.cwd || process.cwd(),
+			fs: options.fs
+		});
+		const config = {
+			...DEFAULT_CONFIG,
 			expose: "all",
 			jsDoc: "extended",
 			markdownDescription: true,
 			fullDescription: true,
-			skipTypeCheck: true,
 			...options,
-			tsconfig: options.tsconfig ? appendPath(options.tsconfig, options.cwd || process.cwd()) : joinPaths(options.cwd || process.cwd(), "tsconfig.json")
+			tsconfig,
+			path: entryFileName,
+			type: exportName,
+			skipTypeCheck: true
 		};
-		console.log(`Generating JSON schema for "${filePath}" using the type "${exportName}" with the following configuration: ${JSON.stringify(generatorConfig, null, 2)}`);
-		return createGenerator(generatorConfig).createSchema(exportName);
+		const tsProgram = createProgramFromSources(entryFileName, sources, config);
+		options.logger?.debug?.(`Generating JSON schema for bundled "${filePath}" using the type "${exportName}" (${sources.size} source file(s))`);
+		return createGenerator({
+			...config,
+			tsProgram
+		}).createSchema(exportName);
 	} 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}`);
 	}
@@ -605,5 +763,5 @@ async function extract(input, options = {}) {
 }
 
 //#endregion
-export { JSON_SCHEMA_METADATA_KEYS, JSON_SCHEMA_PRIMITIVE_TYPES, JSON_SCHEMA_TYPES, JsonSchemaTypeNames, SCHEMA_ARRAY_CONCAT_KEYWORDS, SCHEMA_RECORD_KEYWORDS, SCHEMA_SINGLE_KEYWORDS, addProperty, applyJsonSchemaMetadata, assertSchemasDoNotContradict, bundleReferences, createStoragePromises, extract, extractHash, extractJsonSchema, extractResolvedVariant, extractSchema, extractSchemaWithSource, extractSource, extractTSType, extractVariant, findSchemaContradictions, getJsonSchema, getJsonSchemaObject, getPrimarySchemaType, getProperties, getPropertiesList, getProperty, isFileReference, isJsonSchema, isJsonSchemaAllOf, isJsonSchemaAny, isJsonSchemaAnyOf, isJsonSchemaArray, isJsonSchemaBigint, isJsonSchemaBoolean, isJsonSchemaDate, isJsonSchemaDecimal, isJsonSchemaEnum, isJsonSchemaInteger, isJsonSchemaKeywords, isJsonSchemaLiteral, isJsonSchemaMap, isJsonSchemaNativeEnum, isJsonSchemaNever, isJsonSchemaNull, isJsonSchemaNullable, isJsonSchemaNumber, isJsonSchemaObject, isJsonSchemaPrimitiveType, isJsonSchemaPrimitiveUnion, isJsonSchemaRecord, isJsonSchemaRef, isJsonSchemaSet, isJsonSchemaString, isJsonSchemaTuple, isJsonSchemaType, isJsonSchemaUndefined, isJsonSchemaUnion, isJsonSchemaUnknown, isNullOnlyJsonSchema, isPropertyOptional, isSchema, isSchemaNullable, isSchemaObject, isSchemaOf, isSchemaWithSource, isStandardSchema, isUntypedConfig, isUntypedConfigStrict, isUntypedSchema, isUntypedSchemaStrict, isValibotSchema, isValidSchemaConfigFile, mapStorageToFileSystem, merge, mergeMetadata, normalizeKey, readSchemaTypes, traverseSchema };
+export { JSON_SCHEMA_METADATA_KEYS, JSON_SCHEMA_PRIMITIVE_TYPES, JSON_SCHEMA_TYPES, JsonSchemaTypeNames, SCHEMA_ARRAY_CONCAT_KEYWORDS, SCHEMA_RECORD_KEYWORDS, SCHEMA_SINGLE_KEYWORDS, addProperty, applyJsonSchemaMetadata, assertSchemasDoNotContradict, bundleReferences, createStoragePromises, extract, extractHash, extractJsonSchema, extractResolvedVariant, extractSchema, extractSchemaWithSource, extractSource, extractTSType, extractVariant, findSchemaContradictions, getJsonSchema, getJsonSchemaObject, getPrimarySchemaType, getProperties, getPropertiesList, getProperty, isFileReference, isJsonSchema, isJsonSchemaAllOf, isJsonSchemaAny, isJsonSchemaAnyOf, isJsonSchemaArray, isJsonSchemaBigint, isJsonSchemaBoolean, isJsonSchemaDate, isJsonSchemaDecimal, isJsonSchemaEnum, isJsonSchemaInteger, isJsonSchemaKeywords, isJsonSchemaLiteral, isJsonSchemaMap, isJsonSchemaNativeEnum, isJsonSchemaNever, isJsonSchemaNull, isJsonSchemaNullable, isJsonSchemaNumber, isJsonSchemaObject, isJsonSchemaPrimitiveType, isJsonSchemaPrimitiveUnion, isJsonSchemaRecord, isJsonSchemaRef, isJsonSchemaSet, isJsonSchemaString, isJsonSchemaTuple, isJsonSchemaType, isJsonSchemaUndefined, isJsonSchemaUnion, isJsonSchemaUnknown, isNullOnlyJsonSchema, isPropertyOptional, isSchema, isSchemaNullable, isSchemaObject, isSchemaOf, isSchemaWithSource, isStandardSchema, isUntypedConfig, isUntypedConfigStrict, isUntypedInput, isUntypedInputStrict, isUntypedSchema, isUntypedSchemaStrict, isValibotSchema, isValidSchemaConfigFile, isValidSchemaInputFile, mapStorageToFileSystem, merge, mergeMetadata, normalizeKey, readSchemaTypes, traverseSchema };
 //# sourceMappingURL=index.mjs.map

package/dist/{types-CjF4wIDK.d.mts → types-CyvYSCHO.d.mts}

@@ -1,7 +1,7 @@
+import { Config } from "ts-json-schema-generator/dist/src/Config.js";
 import { BaseIssue, BaseSchema } from "valibot";
 import { StandardJSONSchemaV1 } from "@standard-schema/spec";
 import { InferLoadOptions, LoadReference } from "@stryke/resolve/types";
-import { Config } from "ts-json-schema-generator/dist/src/Config.js";
 import { Storage } from "unstorage";
 import { InputObject, Schema } from "untyped";
 import * as z3 from "zod/v3";
@@ -1347,4 +1347,4 @@ declare module "zod" {
 }
 //#endregion
 export { SchemaSourceVariant as $, JsonSchemaNumberFormat as A, JsonSchemaString as B, JsonSchemaMap as C, JsonSchemaNull as D, JsonSchemaNever as E, JsonSchemaRecord as F, JsonSchemaUnion as G, JsonSchemaTuple as H, JsonSchemaRecordPropertyNames as I, SchemaConfigVariant as J, JsonSchemaUnknown as K, JsonSchemaRef as L, JsonSchemaOf as M, JsonSchemaPrimitiveType as N, JsonSchemaNullable as O, JsonSchemaPrimitiveUnion as P, SchemaSourceConfig as Q, JsonSchemaSchemaSource as R, JsonSchemaLogicKeywords as S, JsonSchemaNativeEnum as T, JsonSchemaType as U, JsonSchemaStringFormat as V, JsonSchemaUndefined as W, SchemaEnvelopeOf as X, SchemaEnvelope as Y, SchemaSource as Z, JsonSchemaInteger as _, JsonSchema as a, ValibotSchema as at, JsonSchemaLike as b, JsonSchemaAnyOf as c, JSON_SCHEMA_METADATA_KEYS as ct, JsonSchemaBoolean as d, JsonSchemaTypeNames as dt, SpecOf as et, JsonSchemaConditionalKeywords as f, SCHEMA_ARRAY_CONCAT_KEYWORDS as ft, JsonSchemaEnum as g, JsonSchemaDecimalFormat as h, InferExtractOptions as i, UntypedSchemaSource as it, JsonSchemaObject as j, JsonSchemaNumber as k, JsonSchemaArray as l, JSON_SCHEMA_PRIMITIVE_TYPES as lt, JsonSchemaDecimal as m, SCHEMA_SINGLE_KEYWORDS as mt, BaseSchemaSource as n, UntypedConfigObject as nt, JsonSchemaAllOf as o, ValibotSchemaSource as ot, JsonSchemaDate as p, SCHEMA_RECORD_KEYWORDS as pt, SchemaConfig as q, ExtractedSchemaEnvelope as r, UntypedSchema as rt, JsonSchemaAny as s, Zod3SchemaSource as st, BaseExtractOptions as t, StandardSchemaSchemaSource as tt, JsonSchemaBigint as u, JSON_SCHEMA_TYPES as ut, JsonSchemaIntegerFormat as v, JsonSchemaMetadataKeywords as w, JsonSchemaLiteral as x, JsonSchemaKeywords as y, JsonSchemaSet as z };
-//# sourceMappingURL=types-CjF4wIDK.d.mts.map
+//# sourceMappingURL=types-CyvYSCHO.d.mts.map

package/dist/types-CyvYSCHO.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-CyvYSCHO.d.mts","names":[],"sources":["../src/constants.ts","../src/types.ts"],"mappings":""}

package/dist/valibot.d.mts

@@ -1,4 +1,4 @@
-import { a as JsonSchema } from "./types-CjF4wIDK.mjs";
+import { a as JsonSchema } from "./types-CyvYSCHO.mjs";
 import * as v from "valibot";
 //#region src/valibot.d.ts
 declare const referenceSchema: v.ObjectSchema<{

package/dist/zod.cjs

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_rolldown_runtime = require('./rolldown-runtime-C_NdSu1c.cjs');
 const require_constants = require('./constants-B7xonHLD.cjs');
-const require_helpers = require('./helpers-sXsSapgI.cjs');
+const require_helpers = require('./helpers-BQD6GZyX.cjs');
 let _stryke_helpers_deep_clone = require("@stryke/helpers/deep-clone");
 let zod_mini = require("zod/mini");
 zod_mini = require_rolldown_runtime.__toESM(zod_mini, 1);

package/dist/zod.d.mts

@@ -1,4 +1,4 @@
-import { Y as SchemaEnvelope, a as JsonSchema } from "./types-CjF4wIDK.mjs";
+import { Y as SchemaEnvelope, a as JsonSchema } from "./types-CyvYSCHO.mjs";
 import * as z from "zod/mini";
 import * as z4 from "zod/v4";
 //#region src/zod.d.ts

package/dist/zod.mjs

@@ -1,5 +1,5 @@
 import { r as JSON_SCHEMA_TYPES } from "./constants-COGt3eeW.mjs";
-import { f as traverseSchema, g as isJsonSchemaAny, n as getJsonSchema } from "./helpers-reqtcaa8.mjs";
+import { _ as isJsonSchemaAny, n as getJsonSchema, p as traverseSchema } from "./helpers-dvxktFml.mjs";
 import { deepClone } from "@stryke/helpers/deep-clone";
 import * as z from "zod/mini";
 import * as z4 from "zod/v4";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@power-plant/schema",
-  "version": "0.0.34",
+  "version": "0.0.35",
   "private": false,
   "description": "A Power Plant utility package to help managing schemas.",
   "keywords": [
@@ -135,6 +135,8 @@
     "@stryke/zod": "^0.3.42",
     "@valibot/to-json-schema": "^1.7.1",
     "defu": "^6.1.7",
+    "esbuild": "^0.28.1",
+    "normalize-path": "^3.0.0",
     "ts-json-schema-generator": "^2.9.0",
     "typescript": "^6.0.3",
     "unstorage": "^1.17.5",
@@ -156,5 +158,5 @@
     "zod": { "optional": true }
   },
   "publishConfig": { "access": "public" },
-  "gitHead": "248ee4fb68fedca6d36ae55e0a23bdc1240d113f"
+  "gitHead": "aa08d1d0c91b8566d9fe9ebe8532fc1a001ccd9c"
 }

package/dist/helpers-reqtcaa8.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"helpers-reqtcaa8.mjs","names":[],"sources":[],"mappings":""}

package/dist/types-CjF4wIDK.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types-CjF4wIDK.d.mts","names":[],"sources":["../src/constants.ts","../src/types.ts"],"mappings":""}