@power-plant/schema 0.0.25 → 0.0.26

package/dist/index.mjs

@@ -1,3 +1,707 @@
-import{a as e,i as t,n,o as r,r as i,s as a,t as o}from"./constants-lk1mMbgx.mjs";import{$ as s,A as c,B as l,C as ee,D as te,E as ne,F as re,G as ie,H as ae,I as oe,J as u,K as d,L as se,M as ce,N as f,O as le,P as ue,Q as p,R as de,S as fe,T as pe,U as me,V as he,W as ge,X as _e,Y as m,Z as h,_ as ve,a as ye,b as be,c as xe,d as Se,et as g,f as Ce,g as we,h as Te,i as Ee,it as _,j as De,k as Oe,l as ke,m as v,n as Ae,nt as je,o as Me,p as y,q as Ne,r as Pe,rt as Fe,s as Ie,t as Le,tt as b,u as Re,v as x,w as ze,x as Be,y as Ve,z as He}from"./helpers-s2Zqtb-K.mjs";import{n as Ue,r as We,t as S}from"./storage-BccFP9xn.mjs";import{isSetObject as C}from"@stryke/type-checks/is-set-object";import{isSetString as w}from"@stryke/type-checks/is-set-string";import{isSetString as T}from"@stryke/type-checks";import{extractFileReference as E}from"@stryke/convert/extract-file-reference";import{resolveSafe as Ge}from"@stryke/fs/resolve";import{murmurhash as D}from"@stryke/hash";import{deepClone as Ke}from"@stryke/helpers/deep-clone";import{isStandardJsonSchema as O}from"@stryke/json";import{findFileExtensionSafe as qe}from"@stryke/path/find";import{VALID_OBJECT_SOURCE_EXTENSIONS as k}from"@stryke/resolve/constants";import{loadSafe as Je}from"@stryke/resolve/load";import{list as Ye}from"@stryke/string-format/list";import{extractJsonSchema as Xe,isZod3Type as A}from"@stryke/zod";import{createFSBackedSystem as Ze,createVirtualCompilerHost as Qe}from"@typescript/vfs";import{toJsonSchema as $e}from"@valibot/to-json-schema";import{dirname as j}from"node:path";import{createGenerator as et}from"ts-json-schema-generator/dist/factory/generator.js";import M from"typescript";const tt=new Set([...o,`default`,`examples`]);function nt(e){return tt.has(e)}function N(e){return!C(e)||e.type===`any`||Object.keys(e).filter(e=>!nt(e)).length===0}function P(e){if(N(e))return`any`;let t=e.type;if(w(t))return[t];if(Array.isArray(t))return t.filter(w);let n=_(e);return n.length>0?n:f(e)?[`object`]:x(e)?[`array`]:`any`}function F(e){return e.length>0?e:`schema`}function I(e,t){return JSON.stringify(e)===JSON.stringify(t)}function L(e,t,n=``){let r=[];if(N(e)||N(t))return r;let i=P(e),a=P(t);if(i!==`any`&&a!==`any`&&i.filter(e=>a.includes(e)).length===0)return r.push(`${F(n)} has conflicting types: ${i.join(`|`)} vs ${a.join(`|`)}`),r;let o=e.const,s=t.const;o!==void 0&&s!==void 0&&!I(o,s)&&r.push(`${F(n)} has conflicting const values`);let c=e.enum,l=t.enum;if(c?.length&&l?.length&&(l.some(e=>c.some(t=>I(t,e)))||r.push(`${F(n)} has enum values that do not overlap`)),f(e)&&f(t)){let i=e.properties??{},a=t.properties??{};for(let[e,t]of Object.entries(a)){let a=i[e],o=n?`${n}.${e}`:e;a&&v(a)&&v(t)&&r.push(...L(a,t,o))}}if(x(e)&&x(t)){let i=e.items,a=t.items;i&&a&&v(i)&&v(a)&&r.push(...L(i,a,n?`${n}[]`:`items`));let o=e.prefixItems,s=t.prefixItems;if(Array.isArray(o)&&Array.isArray(s)){let e=Math.min(o.length,s.length);for(let t=0;t<e;t++){let e=o[t],i=s[t];v(e)&&v(i)&&r.push(...L(e,i,n?`${n}[${t}]`:`[${t}]`))}}}return r}function rt(e,t,n=`schema`){let r=L(e,t);if(r.length>0)throw Error(`The ${n} schema contradicts the generator schema:\n${r.map(e=>`- ${e}`).join(`
-`)}`)}const R=`https://power-plant.invalid/`,z={noEmit:!0,emitDecoratorMetadata:!0,experimentalDecorators:!0,target:M.ScriptTarget.ES2022,module:M.ModuleKind.ESNext,strictNullChecks:!1,skipLibCheck:!0,skipDefaultLibCheck:!0,esModuleInterop:!0};function B(e,t){if(e.readFileSync)try{let n=e.readFileSync(t,`utf8`);return typeof n==`string`?n:void 0}catch{return}}function it(e,t){if(e.existsSync)try{return e.existsSync(t)}catch{return!1}if(e.statSync)try{return e.statSync(t),!0}catch{return!1}return B(e,t)!==void 0}function at(e,t){let n=e.fileExists.bind(e),r=e.readFile.bind(e),i=e.directoryExists.bind(e),a=e.realpath?.bind(e);e.fileExists=e=>it(t,e)||n(e),e.readFile=e=>{if(it(t,e)){let n=B(t,e);if(n!==void 0)return n}return r(e)},e.directoryExists=e=>{try{if(t.statSync){if(t.statSync(e)?.isDirectory?.())return!0}else if(t.existsSync?.(e))return!0}catch{}return i(e)},e.realpath&&t.realpathSync&&(e.realpath=e=>{try{return String(t.realpathSync(e))}catch{return a?.(e)??e}})}function ot(e,t,n){if(!t)return{...z};let r=(n?B(n,t):void 0)??M.sys.readFile(t);if(!r)return{...z};let i=M.parseConfigFileTextToJson(t,r);if(!i.config)return{...z};let a={...M.parseJsonConfigFileContent(i.config,e,j(t),{},t).options,noEmit:!0};return delete a.out,delete a.outDir,delete a.outFile,delete a.declaration,delete a.declarationDir,delete a.declarationMap,a}function st(e,t){let n=t.cwd??j(e),r=Ze,i=Qe,a=r(new Map,n,M);t.fs&&at(a,t.fs);let o=ot(a,t.tsconfig,t.fs),{compilerHost:s}=i(a,o,M);return M.createProgram({rootNames:[e],options:o,host:s})}function ct(e){return!(!C(e)||!(`schema`in e)||`hash`in e||`variant`in e||`source`in e)}function V(e){return ct(e)?e.schema:e}function lt(e){return e.endsWith(`#`)?e.slice(0,-1):e}function H(e){let t=e.indexOf(`#`);return t>=0?e.slice(0,t):e}function ut(e){return e.replaceAll(`~`,`~0`).replaceAll(`/`,`~1`)}function dt(e){return e.length===0?``:`/${e.map(e=>ut(e)).join(`/`)}`}function U(e,t){try{return lt(new URL(e,t).toString())}catch{return lt(e)}}function W(e,t,n,r,i){if(!C(e))return;let a=e,o=dt(t),s=T(a.$id)?U(a.$id,n):n,c=H(s);if(r.set(s,o),r.set(c,o),T(a.$anchor)&&r.set(`${c}#${a.$anchor}`,o),T(a.$dynamicAnchor)){let e=`${c}#${a.$dynamicAnchor}`;r.set(e,o),i.set(e,`#${a.$dynamicAnchor}`)}for(let[e,n]of Object.entries(a)){if(Array.isArray(n)){n.forEach((n,a)=>{W(n,[...t,e,String(a)],s,r,i)});continue}W(n,[...t,e],s,r,i)}}function G(e,t,n,r,i){if(!C(e))return;let a=e,o=T(a.$id)?U(a.$id,n):n;if(T(a.$ref)){let e=U(a.$ref,o),t=r.get(e)??r.get(H(e));t!==void 0&&(a.$ref=t.length>0?`#${t}`:`#`)}if(T(a.$dynamicRef)){let e=U(a.$dynamicRef,o),t=i.get(e);if(t)a.$dynamicRef=t;else{let t=r.get(e)??r.get(H(e));t!==void 0&&(a.$dynamicRef=t.length>0?`#${t}`:`#`)}}for(let[e,n]of Object.entries(a)){if(Array.isArray(n)){n.forEach((n,a)=>{G(n,[...t,e,String(a)],o,r,i)});continue}G(n,[...t,e],o,r,i)}}function K(e){if(!C(e))return e;let t=Ke(e),n=T(t.$id)?U(t.$id,R):R,r=new Map,i=new Map;return W(t,[],n,r,i),G(t,[],n,r,i),t}function q(e){if(s(e))return J(e);if(C(e)){if(h(e))return Y(e);let t=e;if(`$schema`in t&&s(t.$schema))return J(t.$schema)}return e}function ft(e){return Array.isArray(e)?e.map(e=>q(e)):e}function pt(e){return $e(e,{target:`draft-2020-12`})}function J(e){let t=e,n={};for(let[e,r]of Object.entries(t))if(e!==`tsType`&&e!==`markdownType`&&e!==`tags`&&e!==`args`&&e!==`resolve`){if(e===`id`&&T(r)){n.$id=r;continue}if(e===`properties`||e===`patternProperties`||e===`dependentSchemas`||e===`$defs`||e===`definitions`){if(!C(r)){n[e]=r;continue}n[e]=Object.fromEntries(Object.entries(r).map(([e,t])=>[e,q(t)]));continue}if(e===`items`||e===`contains`||e===`if`||e===`then`||e===`else`||e===`not`||e===`propertyNames`||e===`additionalProperties`||e===`unevaluatedProperties`){n[e]=q(r);continue}if(e===`oneOf`||e===`anyOf`||e===`allOf`){n[e]=ft(r);continue}n[e]=r}return n}function Y(e){let t=e,n=s(t.$schema)?J(t.$schema):{},r={};for(let[e,n]of Object.entries(t)){if(e.startsWith(`$`)||!C(n))continue;if(h(n)){r[e]=Y(n);continue}let t=n;if(`$schema`in t&&s(t.$schema)){r[e]=J(t.$schema);continue}s(n)&&(r[e]=J(n))}if(!f(n))throw Error(`Failed to convert untyped input to JSON Schema. The base schema must be a valid JSON Schema object.`);let i={...C(n.properties)?n.properties:{},...r};return{...n,type:n.type??`object`,...Object.keys(i).length>0?{properties:i}:{}}}function X(e,t){let n=V(t);if(m(n)||d(n))return D({variant:e,input:n.schema});if(T(n)||typeof n==`boolean`)return D({variant:e,input:n});if(C(n)){if(A(n))return D({variant:e,input:n._def});if(O(n))return D({variant:e,input:n[`~standard`]});if(v(n))return D({variant:e,input:n});if(b(n))return D({variant:e,input:pt(n)});if(h(n))return D({variant:e,input:Y(n)});if(s(n))return D({variant:e,input:J(n)})}throw 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.`)}function mt(e){if(C(e)){if(A(e))return Xe(e,{target:`draft-2020-12`});if(p(e))return Y(e);if(g(e))return J(e);if(O(e))return e[`~standard`].jsonSchema.input({target:`draft-2020-12`});if(b(e))return pt(e);if(v(e))return e}}function Z(e){if(C(e)){if(A(e))return`zod3`;if(p(e)||g(e))return`untyped`;if(O(e))return`standard-schema`;if(v(e))return`json-schema`;if(b(e))return`valibot`}throw Error(`Failed to determine the variant of the provided schema definition input. The input must be a Zod schema, a Standard JSON Schema, a JSON Schema object, a Valibot BaseSchema, a reflected Deepkit Type object, or an Untyped schema.`)}function ht(e){let t=V(e);return m(t)||d(t)?t.variant:T(t)||y(t)?`file-reference`:Z(t)}async function gt(e,t){if(m(e))return e.schema;let n=t??Z(e),r;if((n===`zod3`||n===`json-schema`||n===`standard-schema`||n===`untyped`||n===`valibot`)&&(r=mt(e)),r)return K(r);throw 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.`)}function Q(e,t){if(e===`zod3`)return{hash:X(e,t),variant:`zod3`,schema:t};if(e===`untyped`)return{hash:X(e,t),variant:`untyped`,schema:t};if(e===`standard-schema`)return{hash:X(e,t),variant:`standard-schema`,schema:t};if(e===`json-schema`)return{hash:X(e,t),variant:`json-schema`,schema:t};if(e===`valibot`)return{hash:X(e,t),variant:`valibot`,schema:t};throw 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.`)}async function _t(e,t={}){let n=E(e);if(!n)throw 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.`);let r=n.export??`*`,i=await Ge(n.file,{fs:t.fs}),a=i||n.file;try{return et({path:a,type:r,expose:`all`,jsDoc:`extended`,markdownDescription:!0,fullDescription:!0,skipTypeCheck:!0,tsProgram:st(a,t),...t}).createSchema(r)}catch(e){throw Error(`Failed to generate a JSON schema for "${n.file}"${i&&i!==n.file?` (resolved: ${i})`:``} using the type "${r}". Error: ${e.message}`)}}async function $(e,t={}){let n=V(e);if(m(n))return n;if(d(n))return{...n,source:{hash:X(`json-schema`,n.schema),variant:`json-schema`,schema:n.schema}};let r,i=ht(n),a=X(i,n);if(i===`file-reference`){let e=E(n);if(!e)throw Error(`Failed to extract a valid file reference from the provided input "${JSON.stringify(n)}". Please ensure that the input is correctly formatted as a file reference (e.g. "./schema.ts#MySchema") and that the file exists at the specified path.`);let i=qe(e.file);if(i&&!k.includes(i))throw Error(`The provided schema file input "${e.file}" has an invalid file extension (.${i}). Please ensure that the file has one of the following extensions: ${Ye(k,{conjunction:`or`})}.`);let a;t.storage&&(a=S(t.storage));let o=await Je(n,{...t,fs:a});o??=await _t(n,{...t,fs:a});let s=V(o);r=m(s)?s.source:d(s)?{hash:X(`json-schema`,s.schema),variant:`json-schema`,schema:s.schema}:Q(Z(s),s)}else if([`json-schema`,`standard-schema`,`zod3`,`untyped`,`valibot`,`reflection`].includes(i))r=Q(i,n);else throw Error(`Invalid schema definition input "${i}". The variant must be one of "file-reference", "json-schema", "standard-schema", "zod3", "valibot", "untyped", or "reflection".`);return{variant:i,source:r,schema:await gt(r.schema,r.variant),hash:a}}async function vt(e,t={}){let n=V(e);if(m(n)||u(n))return n;let r=await $(e,t);if(!r?.schema)throw Error(`Failed to extract a valid schema from the provided input. The input must be a Zod schema, a Valibot schema, any Standard JSON Schema type, a plain JSON Schema object, an untyped schema, or a reflected Deepkit Type object.`);return r}export{o as JSON_SCHEMA_METADATA_KEYS,n as JSON_SCHEMA_PRIMITIVE_TYPES,i as JSON_SCHEMA_TYPES,t as JsonSchemaTypeNames,e as SCHEMA_ARRAY_CONCAT_KEYWORDS,r as SCHEMA_RECORD_KEYWORDS,a as SCHEMA_SINGLE_KEYWORDS,Le as addProperty,je as applyJsonSchemaMetadata,rt as assertSchemasDoNotContradict,K as bundleReferences,Ue as createStoragePromises,vt as extract,X as extractHash,mt as extractJsonSchema,Z as extractResolvedVariant,gt as extractSchema,$ as extractSchemaWithSource,Q as extractSource,_t as extractTSType,ht as extractVariant,L as findSchemaContradictions,Ae as getJsonSchema,Pe as getJsonSchemaObject,Fe as getPrimarySchemaType,Ee as getProperties,ye as getPropertiesList,Me as getProperty,y as isFileReference,v as isJsonSchema,Te as isJsonSchemaAllOf,we as isJsonSchemaAny,ve as isJsonSchemaAnyOf,x as isJsonSchemaArray,Ve as isJsonSchemaBigint,be as isJsonSchemaBoolean,Be as isJsonSchemaDate,fe as isJsonSchemaDecimal,ee as isJsonSchemaEnum,ze as isJsonSchemaInteger,pe as isJsonSchemaKeywords,ne as isJsonSchemaLiteral,te as isJsonSchemaMap,le as isJsonSchemaNativeEnum,Oe as isJsonSchemaNever,c as isJsonSchemaNull,De as isJsonSchemaNullable,ce as isJsonSchemaNumber,f as isJsonSchemaObject,ue as isJsonSchemaPrimitiveType,re as isJsonSchemaPrimitiveUnion,oe as isJsonSchemaRecord,se as isJsonSchemaRef,de as isJsonSchemaSet,He as isJsonSchemaString,l as isJsonSchemaTuple,he as isJsonSchemaType,ae as isJsonSchemaUndefined,me as isJsonSchemaUnion,ge as isJsonSchemaUnknown,ie as isNullOnlyJsonSchema,Ie as isPropertyOptional,d as isSchema,xe as isSchemaNullable,Ne as isSchemaObject,u as isSchemaOf,m as isSchemaWithSource,_e as isStandardSchema,h as isUntypedConfig,p as isUntypedConfigStrict,s as isUntypedSchema,g as isUntypedSchemaStrict,b as isValibotSchema,ke as isValidSchemaConfigFile,S as mapStorageToFileSystem,Re as merge,Se as mergeMetadata,We as normalizeKey,_ as readSchemaTypes,Ce as traverseSchema};
+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 { 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";
+import { isSetString as isSetString$1 } from "@stryke/type-checks";
+import { extractFileReference } from "@stryke/convert/extract-file-reference";
+import { resolveSafe } from "@stryke/fs/resolve";
+import { murmurhash } from "@stryke/hash";
+import { deepClone } from "@stryke/helpers/deep-clone";
+import { isStandardJsonSchema } from "@stryke/json";
+import { findFileExtensionSafe } from "@stryke/path/find";
+import { VALID_OBJECT_SOURCE_EXTENSIONS } from "@stryke/resolve/constants";
+import { loadSafe } from "@stryke/resolve/load";
+import { list } from "@stryke/string-format/list";
+import { extractJsonSchema as extractJsonSchema$1, isZod3Type } from "@stryke/zod";
+import { createFSBackedSystem, createVirtualCompilerHost } from "@typescript/vfs";
+import { toJsonSchema } from "@valibot/to-json-schema";
+import { dirname } from "node:path";
+import { createGenerator } from "ts-json-schema-generator/dist/factory/generator.js";
+import ts from "typescript";
+
+//#region src/compatibility.ts
+const METADATA_KEYS = /* @__PURE__ */ new Set([
+	...JSON_SCHEMA_METADATA_KEYS,
+	"default",
+	"examples"
+]);
+function isMetadataKey(key) {
+	return METADATA_KEYS.has(key);
+}
+function isUnconstrainedSchema(schema) {
+	if (!isSetObject(schema)) return true;
+	if (schema.type === "any") return true;
+	return Object.keys(schema).filter((key) => !isMetadataKey(key)).length === 0;
+}
+function resolveSchemaTypes(schema) {
+	if (isUnconstrainedSchema(schema)) return "any";
+	const schemaType = schema.type;
+	if (isSetString(schemaType)) return [schemaType];
+	if (Array.isArray(schemaType)) return schemaType.filter(isSetString);
+	const primitiveTypes = readSchemaTypes(schema);
+	if (primitiveTypes.length > 0) return primitiveTypes;
+	if (isJsonSchemaObject(schema)) return ["object"];
+	if (isJsonSchemaArray(schema)) return ["array"];
+	return "any";
+}
+function formatPath(path) {
+	return path.length > 0 ? path : "schema";
+}
+function valuesEqual(left, right) {
+	return JSON.stringify(left) === JSON.stringify(right);
+}
+/**
+* Finds structural contradictions between two JSON Schema fragments.
+*
+* @remarks
+* Metadata-only keywords are ignored. Either schema may be unconstrained
+* (`{}`, `{ type: "any" }`, or missing structural keywords) without
+* producing contradictions.
+*
+* @param base - The base JSON Schema fragment.
+* @param override - The JSON Schema fragment to compare against the base.
+* @param path - Optional dot-separated path used in issue messages.
+* @returns A list of human-readable contradiction descriptions.
+*/
+function findSchemaContradictions(base, override, path = "") {
+	const issues = [];
+	if (isUnconstrainedSchema(base) || isUnconstrainedSchema(override)) return issues;
+	const baseTypes = resolveSchemaTypes(base);
+	const overrideTypes = resolveSchemaTypes(override);
+	if (baseTypes !== "any" && overrideTypes !== "any") {
+		if (baseTypes.filter((type) => overrideTypes.includes(type)).length === 0) {
+			issues.push(`${formatPath(path)} has conflicting types: ${baseTypes.join("|")} vs ${overrideTypes.join("|")}`);
+			return issues;
+		}
+	}
+	const baseConst = base.const;
+	const overrideConst = override.const;
+	if (baseConst !== void 0 && overrideConst !== void 0 && !valuesEqual(baseConst, overrideConst)) issues.push(`${formatPath(path)} has conflicting const values`);
+	const baseEnum = base.enum;
+	const overrideEnum = override.enum;
+	if (baseEnum?.length && overrideEnum?.length) {
+		if (!overrideEnum.some((value) => baseEnum.some((baseValue) => valuesEqual(baseValue, value)))) issues.push(`${formatPath(path)} has enum values that do not overlap`);
+	}
+	if (isJsonSchemaObject(base) && isJsonSchemaObject(override)) {
+		const baseProperties = base.properties ?? {};
+		const overrideProperties = override.properties ?? {};
+		for (const [key, overrideProperty] of Object.entries(overrideProperties)) {
+			const baseProperty = baseProperties[key];
+			const propertyPath = path ? `${path}.${key}` : key;
+			if (baseProperty && isJsonSchema(baseProperty) && isJsonSchema(overrideProperty)) issues.push(...findSchemaContradictions(baseProperty, overrideProperty, propertyPath));
+		}
+	}
+	if (isJsonSchemaArray(base) && isJsonSchemaArray(override)) {
+		const baseItems = base.items;
+		const overrideItems = override.items;
+		if (baseItems && overrideItems && isJsonSchema(baseItems) && isJsonSchema(overrideItems)) issues.push(...findSchemaContradictions(baseItems, overrideItems, path ? `${path}[]` : "items"));
+		const basePrefix = base.prefixItems;
+		const overridePrefix = override.prefixItems;
+		if (Array.isArray(basePrefix) && Array.isArray(overridePrefix)) {
+			const length = Math.min(basePrefix.length, overridePrefix.length);
+			for (let index = 0; index < length; index++) {
+				const baseItem = basePrefix[index];
+				const overrideItem = overridePrefix[index];
+				if (isJsonSchema(baseItem) && isJsonSchema(overrideItem)) issues.push(...findSchemaContradictions(baseItem, overrideItem, path ? `${path}[${index}]` : `[${index}]`));
+			}
+		}
+	}
+	return issues;
+}
+/**
+* Asserts that two JSON Schema fragments do not structurally contradict each other.
+*
+* @param base - The base JSON Schema fragment.
+* @param override - The JSON Schema fragment to compare against the base.
+* @param label - A label used in the thrown error message.
+* @throws {Error} When one or more structural contradictions are found.
+*/
+function assertSchemasDoNotContradict(base, override, label = "schema") {
+	const issues = findSchemaContradictions(base, override);
+	if (issues.length > 0) throw new Error(`The ${label} schema contradicts the generator schema:\n${issues.map((issue) => `- ${issue}`).join("\n")}`);
+}
+
+//#endregion
+//#region src/extract.ts
+const SCHEMA_BUNDLE_BASE_URI = "https://power-plant.invalid/";
+const DEFAULT_TS_COMPILER_OPTIONS = {
+	noEmit: true,
+	emitDecoratorMetadata: true,
+	experimentalDecorators: true,
+	target: ts.ScriptTarget.ES2022,
+	module: ts.ModuleKind.ESNext,
+	strictNullChecks: false,
+	skipLibCheck: true,
+	skipDefaultLibCheck: true,
+	esModuleInterop: true
+};
+function readFileAsString(fs, fileName) {
+	if (!fs.readFileSync) return;
+	try {
+		const content = fs.readFileSync(fileName, "utf8");
+		return typeof content === "string" ? content : void 0;
+	} catch {
+		return;
+	}
+}
+function fileExistsOnFs(fs, fileName) {
+	if (fs.existsSync) try {
+		return fs.existsSync(fileName);
+	} catch {
+		return false;
+	}
+	if (fs.statSync) try {
+		fs.statSync(fileName);
+		return true;
+	} catch {
+		return false;
+	}
+	return readFileAsString(fs, fileName) !== void 0;
+}
+/**
+* Prefers `options.fs` for System I/O so virtual storage-backed files resolve
+* through createFSBackedSystem instead of only the real disk.
+*/
+function bindFileSystemToSystem(system, fs) {
+	const baseFileExists = system.fileExists.bind(system);
+	const baseReadFile = system.readFile.bind(system);
+	const baseDirectoryExists = system.directoryExists.bind(system);
+	const baseRealpath = system.realpath?.bind(system);
+	system.fileExists = (fileName) => fileExistsOnFs(fs, fileName) || baseFileExists(fileName);
+	system.readFile = (fileName) => {
+		if (fileExistsOnFs(fs, fileName)) {
+			const content = readFileAsString(fs, fileName);
+			if (content !== void 0) return content;
+		}
+		return baseReadFile(fileName);
+	};
+	system.directoryExists = (directory) => {
+		try {
+			if (fs.statSync) {
+				if (fs.statSync(directory)?.isDirectory?.()) return true;
+			} else if (fs.existsSync?.(directory)) return true;
+		} catch {}
+		return baseDirectoryExists(directory);
+	};
+	if (system.realpath && fs.realpathSync) system.realpath = (path) => {
+		try {
+			return String(fs.realpathSync(path));
+		} catch {
+			return baseRealpath?.(path) ?? path;
+		}
+	};
+}
+function resolveCompilerOptions(system, tsconfig, fs) {
+	if (!tsconfig) return { ...DEFAULT_TS_COMPILER_OPTIONS };
+	const raw = (fs ? readFileAsString(fs, tsconfig) : void 0) ?? ts.sys.readFile(tsconfig);
+	if (!raw) return { ...DEFAULT_TS_COMPILER_OPTIONS };
+	const parsed = ts.parseConfigFileTextToJson(tsconfig, raw);
+	if (!parsed.config) return { ...DEFAULT_TS_COMPILER_OPTIONS };
+	const options = {
+		...ts.parseJsonConfigFileContent(parsed.config, system, dirname(tsconfig), {}, tsconfig).options,
+		noEmit: true
+	};
+	delete options.out;
+	delete options.outDir;
+	delete options.outFile;
+	delete options.declaration;
+	delete options.declarationDir;
+	delete options.declarationMap;
+	return options;
+}
+function createProgramFromFileSystem(rootFile, options) {
+	const projectRoot = options.cwd ?? dirname(rootFile);
+	const createSystem = createFSBackedSystem;
+	const createHost = createVirtualCompilerHost;
+	const system = createSystem(/* @__PURE__ */ new Map(), projectRoot, ts);
+	if (options.fs) bindFileSystemToSystem(system, options.fs);
+	const compilerOptions = resolveCompilerOptions(system, options.tsconfig, options.fs);
+	const { compilerHost } = createHost(system, compilerOptions, ts);
+	return ts.createProgram({
+		rootNames: [rootFile],
+		options: compilerOptions,
+		host: compilerHost
+	});
+}
+function isWrappedSchemaConfig(input) {
+	if (!isSetObject(input) || !("schema" in input)) return false;
+	if ("hash" in input || "variant" in input || "source" in input) return false;
+	return true;
+}
+function unwrapSchemaConfig(input) {
+	if (isWrappedSchemaConfig(input)) return input.schema;
+	return input;
+}
+function normalizeUri(uri) {
+	return uri.endsWith("#") ? uri.slice(0, -1) : uri;
+}
+function stripUriFragment(uri) {
+	const hashIndex = uri.indexOf("#");
+	return hashIndex >= 0 ? uri.slice(0, hashIndex) : uri;
+}
+function escapeJsonPointerToken(token) {
+	return token.replaceAll("~", "~0").replaceAll("/", "~1");
+}
+function toJsonPointer(path) {
+	if (path.length === 0) return "";
+	return `/${path.map((segment) => escapeJsonPointerToken(segment)).join("/")}`;
+}
+function resolveUri(reference, baseUri) {
+	try {
+		return normalizeUri(new URL(reference, baseUri).toString());
+	} catch {
+		return normalizeUri(reference);
+	}
+}
+function collectReferenceTargets(value, path, baseUri, uriToPointer, dynamicUriToFragment) {
+	if (!isSetObject(value)) return;
+	const schema = value;
+	const pointer = toJsonPointer(path);
+	const currentBaseUri = isSetString$1(schema.$id) ? resolveUri(schema.$id, baseUri) : baseUri;
+	const currentDocumentUri = stripUriFragment(currentBaseUri);
+	uriToPointer.set(currentBaseUri, pointer);
+	uriToPointer.set(currentDocumentUri, pointer);
+	if (isSetString$1(schema.$anchor)) uriToPointer.set(`${currentDocumentUri}#${schema.$anchor}`, pointer);
+	if (isSetString$1(schema.$dynamicAnchor)) {
+		const dynamicTarget = `${currentDocumentUri}#${schema.$dynamicAnchor}`;
+		uriToPointer.set(dynamicTarget, pointer);
+		dynamicUriToFragment.set(dynamicTarget, `#${schema.$dynamicAnchor}`);
+	}
+	for (const [key, child] of Object.entries(schema)) {
+		if (Array.isArray(child)) {
+			child.forEach((entry, index) => {
+				collectReferenceTargets(entry, [
+					...path,
+					key,
+					String(index)
+				], currentBaseUri, uriToPointer, dynamicUriToFragment);
+			});
+			continue;
+		}
+		collectReferenceTargets(child, [...path, key], currentBaseUri, uriToPointer, dynamicUriToFragment);
+	}
+}
+function rewriteReferenceTargets(value, path, baseUri, uriToPointer, dynamicUriToFragment) {
+	if (!isSetObject(value)) return;
+	const schema = value;
+	const currentBaseUri = isSetString$1(schema.$id) ? resolveUri(schema.$id, baseUri) : baseUri;
+	if (isSetString$1(schema.$ref)) {
+		const resolvedRefUri = resolveUri(schema.$ref, currentBaseUri);
+		const pointer = uriToPointer.get(resolvedRefUri) ?? uriToPointer.get(stripUriFragment(resolvedRefUri));
+		if (pointer !== void 0) schema.$ref = pointer.length > 0 ? `#${pointer}` : "#";
+	}
+	if (isSetString$1(schema.$dynamicRef)) {
+		const resolvedDynamicRefUri = resolveUri(schema.$dynamicRef, currentBaseUri);
+		const dynamicFragment = dynamicUriToFragment.get(resolvedDynamicRefUri);
+		if (dynamicFragment) schema.$dynamicRef = dynamicFragment;
+		else {
+			const pointer = uriToPointer.get(resolvedDynamicRefUri) ?? uriToPointer.get(stripUriFragment(resolvedDynamicRefUri));
+			if (pointer !== void 0) schema.$dynamicRef = pointer.length > 0 ? `#${pointer}` : "#";
+		}
+	}
+	for (const [key, child] of Object.entries(schema)) {
+		if (Array.isArray(child)) {
+			child.forEach((entry, index) => {
+				rewriteReferenceTargets(entry, [
+					...path,
+					key,
+					String(index)
+				], currentBaseUri, uriToPointer, dynamicUriToFragment);
+			});
+			continue;
+		}
+		rewriteReferenceTargets(child, [...path, key], currentBaseUri, uriToPointer, dynamicUriToFragment);
+	}
+}
+/**
+* Bundles all external references in a JSON Schema into a single schema document by collecting all reference targets and rewriting the references to point to the bundled definitions. This ensures that the resulting schema is self-contained and can be used independently without relying on external documents.
+*
+* @param schema - The JSON Schema to bundle references for.
+* @returns A new JSON Schema with all references bundled and rewritten to point to the bundled definitions.
+*/
+function bundleReferences(schema) {
+	if (!isSetObject(schema)) return schema;
+	const bundledSchema = deepClone(schema);
+	const baseUri = isSetString$1(bundledSchema.$id) ? resolveUri(bundledSchema.$id, SCHEMA_BUNDLE_BASE_URI) : SCHEMA_BUNDLE_BASE_URI;
+	const uriToPointer = /* @__PURE__ */ new Map();
+	const dynamicUriToFragment = /* @__PURE__ */ new Map();
+	collectReferenceTargets(bundledSchema, [], baseUri, uriToPointer, dynamicUriToFragment);
+	rewriteReferenceTargets(bundledSchema, [], baseUri, uriToPointer, dynamicUriToFragment);
+	return bundledSchema;
+}
+function convertNestedUntypedSchema(value) {
+	if (isUntypedSchema(value)) return convertUntypedSchemaToJsonSchema(value);
+	if (isSetObject(value)) {
+		if (isUntypedConfig(value)) return convertUntypedConfigToJsonSchema(value);
+		const nested = value;
+		if ("$schema" in nested && isUntypedSchema(nested.$schema)) return convertUntypedSchemaToJsonSchema(nested.$schema);
+	}
+	return value;
+}
+function convertNestedUntypedSchemaArray(value) {
+	if (!Array.isArray(value)) return value;
+	return value.map((item) => convertNestedUntypedSchema(item));
+}
+function convertValibotSchemaToJsonSchema(schema) {
+	return toJsonSchema(schema, { target: "draft-2020-12" });
+}
+function convertUntypedSchemaToJsonSchema(schema) {
+	const source = schema;
+	const jsonSchema = {};
+	for (const [key, value] of Object.entries(source)) {
+		if (key === "tsType" || key === "markdownType" || key === "tags" || key === "args" || key === "resolve") continue;
+		if (key === "id" && isSetString$1(value)) {
+			jsonSchema.$id = value;
+			continue;
+		}
+		if (key === "properties" || key === "patternProperties" || key === "dependentSchemas" || key === "$defs" || key === "definitions") {
+			if (!isSetObject(value)) {
+				jsonSchema[key] = value;
+				continue;
+			}
+			jsonSchema[key] = Object.fromEntries(Object.entries(value).map(([propertyKey, propertyValue]) => [propertyKey, convertNestedUntypedSchema(propertyValue)]));
+			continue;
+		}
+		if (key === "items" || key === "contains" || key === "if" || key === "then" || key === "else" || key === "not" || key === "propertyNames" || key === "additionalProperties" || key === "unevaluatedProperties") {
+			jsonSchema[key] = convertNestedUntypedSchema(value);
+			continue;
+		}
+		if (key === "oneOf" || key === "anyOf" || key === "allOf") {
+			jsonSchema[key] = convertNestedUntypedSchemaArray(value);
+			continue;
+		}
+		jsonSchema[key] = value;
+	}
+	return jsonSchema;
+}
+function convertUntypedConfigToJsonSchema(input) {
+	const inputObject = input;
+	const base = isUntypedSchema(inputObject.$schema) ? convertUntypedSchemaToJsonSchema(inputObject.$schema) : {};
+	const properties = {};
+	for (const [key, value] of Object.entries(inputObject)) {
+		if (key.startsWith("$")) continue;
+		if (!isSetObject(value)) continue;
+		if (isUntypedConfig(value)) {
+			properties[key] = convertUntypedConfigToJsonSchema(value);
+			continue;
+		}
+		const nested = value;
+		if ("$schema" in nested && isUntypedSchema(nested.$schema)) {
+			properties[key] = convertUntypedSchemaToJsonSchema(nested.$schema);
+			continue;
+		}
+		if (isUntypedSchema(value)) properties[key] = convertUntypedSchemaToJsonSchema(value);
+	}
+	if (!isJsonSchemaObject(base)) throw new Error(`Failed to convert untyped input to JSON Schema. The base schema must be a valid JSON Schema object.`);
+	const mergedProperties = {
+		...isSetObject(base.properties) ? base.properties : {},
+		...properties
+	};
+	return {
+		...base,
+		type: base.type ?? "object",
+		...Object.keys(mergedProperties).length > 0 ? { properties: mergedProperties } : {}
+	};
+}
+/**
+* Creates a hash string for a given schema definition input.
+*/
+function extractHash(variant, input) {
+	const unwrappedConfig = unwrapSchemaConfig(input);
+	if (isSchemaWithSource(unwrappedConfig) || isSchema(unwrappedConfig)) return murmurhash({
+		variant,
+		input: unwrappedConfig.schema
+	});
+	if (isSetString$1(unwrappedConfig)) return murmurhash({
+		variant,
+		input: unwrappedConfig
+	});
+	else if (typeof unwrappedConfig === "boolean") return murmurhash({
+		variant,
+		input: unwrappedConfig
+	});
+	else if (isSetObject(unwrappedConfig)) {
+		if (isZod3Type(unwrappedConfig)) return murmurhash({
+			variant,
+			input: unwrappedConfig._def
+		});
+		else if (isStandardJsonSchema(unwrappedConfig)) return murmurhash({
+			variant,
+			input: unwrappedConfig["~standard"]
+		});
+		else if (isJsonSchema(unwrappedConfig)) return murmurhash({
+			variant,
+			input: unwrappedConfig
+		});
+		else if (isValibotSchema(unwrappedConfig)) return murmurhash({
+			variant,
+			input: convertValibotSchemaToJsonSchema(unwrappedConfig)
+		});
+		else if (isUntypedConfig(unwrappedConfig)) return murmurhash({
+			variant,
+			input: convertUntypedConfigToJsonSchema(unwrappedConfig)
+		});
+		else if (isUntypedSchema(unwrappedConfig)) return murmurhash({
+			variant,
+			input: convertUntypedSchemaToJsonSchema(unwrappedConfig)
+		});
+	}
+	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.`);
+}
+/**
+* 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.
+* @returns The extracted JSON Schema, or `undefined` if the input is not a supported schema type.
+*/
+function extractJsonSchema(schema) {
+	if (isSetObject(schema)) {
+		if (isZod3Type(schema)) return extractJsonSchema$1(schema, { target: "draft-2020-12" });
+		if (isUntypedConfigStrict(schema)) return convertUntypedConfigToJsonSchema(schema);
+		if (isUntypedSchemaStrict(schema)) return convertUntypedSchemaToJsonSchema(schema);
+		if (isStandardJsonSchema(schema)) return schema["~standard"].jsonSchema.input({ target: "draft-2020-12" });
+		if (isValibotSchema(schema)) return convertValibotSchemaToJsonSchema(schema);
+		if (isJsonSchema(schema)) return schema;
+	}
+}
+/**
+* Resolves the concrete source variant for a schema source input.
+*
+* @param input - The schema source input to inspect.
+* @returns The resolved schema source variant.
+* @throws Will throw an error when the input cannot be mapped to a supported source variant.
+*/
+function extractResolvedVariant(input) {
+	if (isSetObject(input)) {
+		if (isZod3Type(input)) return "zod3";
+		else if (isUntypedConfigStrict(input) || isUntypedSchemaStrict(input)) return "untyped";
+		else if (isStandardJsonSchema(input)) return "standard-schema";
+		else if (isJsonSchema(input)) return "json-schema";
+		else if (isValibotSchema(input)) return "valibot";
+	}
+	throw new Error(`Failed to determine the variant of the provided schema definition input. The input must be a Zod schema, a Standard JSON Schema, a JSON Schema object, a Valibot BaseSchema, a reflected Deepkit Type object, or an Untyped schema.`);
+}
+/**
+* Determines the top-level input variant for schema extraction.
+*
+* @param input - The schema input to classify.
+* @returns The resolved schema input variant.
+*/
+function extractVariant(input) {
+	const unwrappedConfig = unwrapSchemaConfig(input);
+	if (isSchemaWithSource(unwrappedConfig) || isSchema(unwrappedConfig)) return unwrappedConfig.variant;
+	if (isSetString$1(unwrappedConfig) || isFileReference(unwrappedConfig)) return "file-reference";
+	return extractResolvedVariant(unwrappedConfig);
+}
+/**
+* Extracts and normalizes a JSON Schema from a concrete schema source input.
+*
+* @param input - The schema source input to extract from.
+* @param variant - Optional source variant override. When omitted, the variant is inferred from the input.
+* @returns A promise that resolves to a bundled JSON Schema.
+* @throws Will throw an error if no valid JSON Schema can be extracted from the input.
+*/
+async function extractSchema(input, variant) {
+	if (isSchemaWithSource(input)) return input.schema;
+	const resolvedVariant = variant ?? extractResolvedVariant(input);
+	let schema;
+	if (resolvedVariant === "zod3" || resolvedVariant === "json-schema" || resolvedVariant === "standard-schema" || resolvedVariant === "untyped" || resolvedVariant === "valibot") schema = extractJsonSchema(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.`);
+}
+/**
+* Builds source metadata for a schema input using a known source variant.
+*
+* @param variant - The schema source variant associated with the input.
+* @param input - The schema source input to wrap.
+* @returns The normalized schema source payload, including the source hash and variant.
+* @throws Will throw an error if the provided variant is unsupported.
+*/
+function extractSource(variant, input) {
+	if (variant === "zod3") return {
+		hash: extractHash(variant, input),
+		variant: "zod3",
+		schema: input
+	};
+	else if (variant === "untyped") return {
+		hash: extractHash(variant, input),
+		variant: "untyped",
+		schema: input
+	};
+	else if (variant === "standard-schema") return {
+		hash: extractHash(variant, input),
+		variant: "standard-schema",
+		schema: input
+	};
+	else if (variant === "json-schema") return {
+		hash: extractHash(variant, input),
+		variant: "json-schema",
+		schema: input
+	};
+	else if (variant === "valibot") return {
+		hash: extractHash(variant, input),
+		variant: "valibot",
+		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.`);
+}
+/**
+* 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.
+*
+* @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.
+* @returns A promise that resolves to the generated JSON Schema.
+*/
+async function extractTSType(input, options = {}) {
+	const fileReference = 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 resolvedPath = await resolveSafe(fileReference.file, { fs: options.fs });
+	const filePath = resolvedPath || fileReference.file;
+	try {
+		return createGenerator({
+			path: filePath,
+			type: exportName,
+			expose: "all",
+			jsDoc: "extended",
+			markdownDescription: true,
+			fullDescription: true,
+			skipTypeCheck: true,
+			tsProgram: createProgramFromFileSystem(filePath, options),
+			...options
+		}).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}`);
+	}
+}
+/**
+* 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.
+*
+* @example
+* ```ts
+* Resolve a schema definition from a JSON schema file
+* const schema1 = await extract(context, "./schemas/my-json-schema.json");
+* // Resolve a schema definition from a TypeScript module export
+* const schema2 = await extract(context, "./schemas.ts#MySchema");
+* // Resolve a schema definition from a JSON Schema object
+* const schema3 = await extract(context, schemaObject);
+* // Resolve a schema definition from a Zod schema
+* 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);
+* ```
+*
+* @see https://zod.dev/
+* @see https://valibot.dev/
+* @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://github.com/unjs/untyped
+* @see https://www.typescriptlang.org/docs/handbook/2/types-from-types.html
+*
+* @param input - The schema definition input to extract, 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.
+* @param options - Optional overrides for the configuration used during extraction.
+* @returns A promise that resolves to the extracted and normalized schema as a JSON Schema object.
+* @throws Will throw an error if the input is not a valid schema definition or if the extraction process fails to produce a valid schema.
+*/
+async function extractSchemaWithSource(input, options = {}) {
+	const unwrappedConfig = unwrapSchemaConfig(input);
+	if (isSchemaWithSource(unwrappedConfig)) return unwrappedConfig;
+	if (isSchema(unwrappedConfig)) return {
+		...unwrappedConfig,
+		source: {
+			hash: extractHash("json-schema", unwrappedConfig.schema),
+			variant: "json-schema",
+			schema: unwrappedConfig.schema
+		}
+	};
+	let source;
+	const variant = extractVariant(unwrappedConfig);
+	const hash = extractHash(variant, unwrappedConfig);
+	if (variant === "file-reference") {
+		const fileReference = extractFileReference(unwrappedConfig);
+		if (!fileReference) throw new Error(`Failed to extract a valid file reference from the provided input "${JSON.stringify(unwrappedConfig)}". Please ensure that the input is correctly formatted as a file reference (e.g. "./schema.ts#MySchema") and that the file exists at the specified path.`);
+		const extension = findFileExtensionSafe(fileReference.file);
+		if (extension && !VALID_OBJECT_SOURCE_EXTENSIONS.includes(extension)) throw new Error(`The provided schema file input "${fileReference.file}" has an invalid file extension (.${extension}). Please ensure that the file has one of the following extensions: ${list(VALID_OBJECT_SOURCE_EXTENSIONS, { conjunction: "or" })}.`);
+		let fs;
+		if (options.storage) fs = mapStorageToFileSystem(options.storage);
+		let resolved = await loadSafe(unwrappedConfig, {
+			...options,
+			fs
+		});
+		resolved ??= await extractTSType(unwrappedConfig, {
+			...options,
+			fs
+		});
+		const resolvedConfig = unwrapSchemaConfig(resolved);
+		if (isSchemaWithSource(resolvedConfig)) source = resolvedConfig.source;
+		else if (isSchema(resolvedConfig)) source = {
+			hash: extractHash("json-schema", resolvedConfig.schema),
+			variant: "json-schema",
+			schema: resolvedConfig.schema
+		};
+		else source = extractSource(extractResolvedVariant(resolvedConfig), resolvedConfig);
+	} else if ([
+		"json-schema",
+		"standard-schema",
+		"zod3",
+		"untyped",
+		"valibot",
+		"reflection"
+	].includes(variant)) source = extractSource(variant, unwrappedConfig);
+	else throw new Error(`Invalid schema definition input "${variant}". The variant must be one of "file-reference", "json-schema", "standard-schema", "zod3", "valibot", "untyped", or "reflection".`);
+	return {
+		variant,
+		source,
+		schema: await extractSchema(source.schema, source.variant),
+		hash
+	};
+}
+/**
+* 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.
+*
+* @example
+* ```ts
+* Resolve a schema definition from a JSON schema file
+* const schema1 = await extract(context, "./schemas/my-json-schema.json");
+* // Resolve a schema definition from a TypeScript module export
+* const schema2 = await extract(context, "./schemas.ts#MySchema");
+* // Resolve a schema definition from a JSON Schema object
+* const schema3 = await extract(context, schemaObject);
+* // Resolve a schema definition from a Zod schema
+* 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);
+* ```
+*
+* @see https://zod.dev/
+* @see https://valibot.dev/
+* @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://github.com/unjs/untyped
+* @see https://www.typescriptlang.org/docs/handbook/2/types-from-types.html
+*
+* @param input - The schema definition input to extract, 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.
+* @param options - Optional overrides for the configuration used during extraction.
+* @returns A promise that resolves to the extracted and normalized schema as a JSON Schema object.
+* @throws Will throw an error if the input is not a valid schema definition or if the extraction process fails to produce a valid schema.
+*/
+async function extract(input, options = {}) {
+	const unwrappedConfig = unwrapSchemaConfig(input);
+	if (isSchemaWithSource(unwrappedConfig) || isSchemaOf(unwrappedConfig)) return unwrappedConfig;
+	const result = await extractSchemaWithSource(input, options);
+	if (!result?.schema) throw new Error(`Failed to extract a valid schema from the provided input. The input must be a Zod schema, a Valibot schema, any Standard JSON Schema type, a plain JSON Schema object, an untyped schema, or a reflected Deepkit Type object.`);
+	return result;
+}
+
+//#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 };
 //# sourceMappingURL=index.mjs.map