@power-plant/schema 0.0.25 → 0.0.26

package/dist/index.cjs

@@ -1,2 +1,788 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./rolldown-runtime-CMqjfN_6.cjs"),t=require("./constants-CjTQhR-l.cjs"),n=require("./helpers-CFED4EbH.cjs"),r=require("./storage-CgfRQlqS.cjs");let i=require("@stryke/type-checks/is-set-object"),a=require("@stryke/type-checks/is-set-string"),o=require("@stryke/type-checks"),s=require("@stryke/convert/extract-file-reference"),c=require("@stryke/fs/resolve"),l=require("@stryke/hash"),u=require("@stryke/helpers/deep-clone"),d=require("@stryke/json"),f=require("@stryke/path/find"),p=require("@stryke/resolve/constants"),m=require("@stryke/resolve/load"),h=require("@stryke/string-format/list"),g=require("@stryke/zod"),_=require("@typescript/vfs"),ee=require("@valibot/to-json-schema"),v=require("node:path"),te=require("ts-json-schema-generator/dist/factory/generator.js"),y=require("typescript");y=e.t(y,1);const ne=new Set([...t.t,`default`,`examples`]);function re(e){return ne.has(e)}function b(e){return!(0,i.isSetObject)(e)||e.type===`any`||Object.keys(e).filter(e=>!re(e)).length===0}function x(e){if(b(e))return`any`;let t=e.type;if((0,a.isSetString)(t))return[t];if(Array.isArray(t))return t.filter(a.isSetString);let r=n.it(e);return r.length>0?r:n.N(e)?[`object`]:n.v(e)?[`array`]:`any`}function S(e){return e.length>0?e:`schema`}function C(e,t){return JSON.stringify(e)===JSON.stringify(t)}function w(e,t,r=``){let i=[];if(b(e)||b(t))return i;let a=x(e),o=x(t);if(a!==`any`&&o!==`any`&&a.filter(e=>o.includes(e)).length===0)return i.push(`${S(r)} has conflicting types: ${a.join(`|`)} vs ${o.join(`|`)}`),i;let s=e.const,c=t.const;s!==void 0&&c!==void 0&&!C(s,c)&&i.push(`${S(r)} has conflicting const values`);let l=e.enum,u=t.enum;if(l?.length&&u?.length&&(u.some(e=>l.some(t=>C(t,e)))||i.push(`${S(r)} has enum values that do not overlap`)),n.N(e)&&n.N(t)){let a=e.properties??{},o=t.properties??{};for(let[e,t]of Object.entries(o)){let o=a[e],s=r?`${r}.${e}`:e;o&&n.m(o)&&n.m(t)&&i.push(...w(o,t,s))}}if(n.v(e)&&n.v(t)){let a=e.items,o=t.items;a&&o&&n.m(a)&&n.m(o)&&i.push(...w(a,o,r?`${r}[]`:`items`));let s=e.prefixItems,c=t.prefixItems;if(Array.isArray(s)&&Array.isArray(c)){let e=Math.min(s.length,c.length);for(let t=0;t<e;t++){let e=s[t],a=c[t];n.m(e)&&n.m(a)&&i.push(...w(e,a,r?`${r}[${t}]`:`[${t}]`))}}}return i}function T(e,t,n=`schema`){let r=w(e,t);if(r.length>0)throw Error(`The ${n} schema contradicts the generator schema:\n${r.map(e=>`- ${e}`).join(`
-`)}`)}const E=`https://power-plant.invalid/`,D={noEmit:!0,emitDecoratorMetadata:!0,experimentalDecorators:!0,target:y.default.ScriptTarget.ES2022,module:y.default.ModuleKind.ESNext,strictNullChecks:!1,skipLibCheck:!0,skipDefaultLibCheck:!0,esModuleInterop:!0};function O(e,t){if(e.readFileSync)try{let n=e.readFileSync(t,`utf8`);return typeof n==`string`?n:void 0}catch{return}}function k(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 O(e,t)!==void 0}function A(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=>k(t,e)||n(e),e.readFile=e=>{if(k(t,e)){let n=O(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 j(e,t,n){if(!t)return{...D};let r=(n?O(n,t):void 0)??y.default.sys.readFile(t);if(!r)return{...D};let i=y.default.parseConfigFileTextToJson(t,r);if(!i.config)return{...D};let a={...y.default.parseJsonConfigFileContent(i.config,e,(0,v.dirname)(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 M(e,t){let n=t.cwd??(0,v.dirname)(e),r=_.createFSBackedSystem,i=_.createVirtualCompilerHost,a=r(new Map,n,y.default);t.fs&&A(a,t.fs);let o=j(a,t.tsconfig,t.fs),{compilerHost:s}=i(a,o,y.default);return y.default.createProgram({rootNames:[e],options:o,host:s})}function N(e){return!(!(0,i.isSetObject)(e)||!(`schema`in e)||`hash`in e||`variant`in e||`source`in e)}function P(e){return N(e)?e.schema:e}function F(e){return e.endsWith(`#`)?e.slice(0,-1):e}function I(e){let t=e.indexOf(`#`);return t>=0?e.slice(0,t):e}function ie(e){return e.replaceAll(`~`,`~0`).replaceAll(`/`,`~1`)}function ae(e){return e.length===0?``:`/${e.map(e=>ie(e)).join(`/`)}`}function L(e,t){try{return F(new URL(e,t).toString())}catch{return F(e)}}function R(e,t,n,r,a){if(!(0,i.isSetObject)(e))return;let s=e,c=ae(t),l=(0,o.isSetString)(s.$id)?L(s.$id,n):n,u=I(l);if(r.set(l,c),r.set(u,c),(0,o.isSetString)(s.$anchor)&&r.set(`${u}#${s.$anchor}`,c),(0,o.isSetString)(s.$dynamicAnchor)){let e=`${u}#${s.$dynamicAnchor}`;r.set(e,c),a.set(e,`#${s.$dynamicAnchor}`)}for(let[e,n]of Object.entries(s)){if(Array.isArray(n)){n.forEach((n,i)=>{R(n,[...t,e,String(i)],l,r,a)});continue}R(n,[...t,e],l,r,a)}}function z(e,t,n,r,a){if(!(0,i.isSetObject)(e))return;let s=e,c=(0,o.isSetString)(s.$id)?L(s.$id,n):n;if((0,o.isSetString)(s.$ref)){let e=L(s.$ref,c),t=r.get(e)??r.get(I(e));t!==void 0&&(s.$ref=t.length>0?`#${t}`:`#`)}if((0,o.isSetString)(s.$dynamicRef)){let e=L(s.$dynamicRef,c),t=a.get(e);if(t)s.$dynamicRef=t;else{let t=r.get(e)??r.get(I(e));t!==void 0&&(s.$dynamicRef=t.length>0?`#${t}`:`#`)}}for(let[e,n]of Object.entries(s)){if(Array.isArray(n)){n.forEach((n,i)=>{z(n,[...t,e,String(i)],c,r,a)});continue}z(n,[...t,e],c,r,a)}}function B(e){if(!(0,i.isSetObject)(e))return e;let t=(0,u.deepClone)(e),n=(0,o.isSetString)(t.$id)?L(t.$id,E):E,r=new Map,a=new Map;return R(t,[],n,r,a),z(t,[],n,r,a),t}function V(e){if(n.$(e))return W(e);if((0,i.isSetObject)(e)){if(n.Z(e))return G(e);let t=e;if(`$schema`in t&&n.$(t.$schema))return W(t.$schema)}return e}function H(e){return Array.isArray(e)?e.map(e=>V(e)):e}function U(e){return(0,ee.toJsonSchema)(e,{target:`draft-2020-12`})}function W(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`&&(0,o.isSetString)(r)){n.$id=r;continue}if(e===`properties`||e===`patternProperties`||e===`dependentSchemas`||e===`$defs`||e===`definitions`){if(!(0,i.isSetObject)(r)){n[e]=r;continue}n[e]=Object.fromEntries(Object.entries(r).map(([e,t])=>[e,V(t)]));continue}if(e===`items`||e===`contains`||e===`if`||e===`then`||e===`else`||e===`not`||e===`propertyNames`||e===`additionalProperties`||e===`unevaluatedProperties`){n[e]=V(r);continue}if(e===`oneOf`||e===`anyOf`||e===`allOf`){n[e]=H(r);continue}n[e]=r}return n}function G(e){let t=e,r=n.$(t.$schema)?W(t.$schema):{},a={};for(let[e,r]of Object.entries(t)){if(e.startsWith(`$`)||!(0,i.isSetObject)(r))continue;if(n.Z(r)){a[e]=G(r);continue}let t=r;if(`$schema`in t&&n.$(t.$schema)){a[e]=W(t.$schema);continue}n.$(r)&&(a[e]=W(r))}if(!n.N(r))throw Error(`Failed to convert untyped input to JSON Schema. The base schema must be a valid JSON Schema object.`);let o={...(0,i.isSetObject)(r.properties)?r.properties:{},...a};return{...r,type:r.type??`object`,...Object.keys(o).length>0?{properties:o}:{}}}function K(e,t){let r=P(t);if(n.Y(r)||n.K(r))return(0,l.murmurhash)({variant:e,input:r.schema});if((0,o.isSetString)(r)||typeof r==`boolean`)return(0,l.murmurhash)({variant:e,input:r});if((0,i.isSetObject)(r)){if((0,g.isZod3Type)(r))return(0,l.murmurhash)({variant:e,input:r._def});if((0,d.isStandardJsonSchema)(r))return(0,l.murmurhash)({variant:e,input:r[`~standard`]});if(n.m(r))return(0,l.murmurhash)({variant:e,input:r});if(n.tt(r))return(0,l.murmurhash)({variant:e,input:U(r)});if(n.Z(r))return(0,l.murmurhash)({variant:e,input:G(r)});if(n.$(r))return(0,l.murmurhash)({variant:e,input:W(r)})}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 q(e){if((0,i.isSetObject)(e)){if((0,g.isZod3Type)(e))return(0,g.extractJsonSchema)(e,{target:`draft-2020-12`});if(n.Q(e))return G(e);if(n.et(e))return W(e);if((0,d.isStandardJsonSchema)(e))return e[`~standard`].jsonSchema.input({target:`draft-2020-12`});if(n.tt(e))return U(e);if(n.m(e))return e}}function J(e){if((0,i.isSetObject)(e)){if((0,g.isZod3Type)(e))return`zod3`;if(n.Q(e)||n.et(e))return`untyped`;if((0,d.isStandardJsonSchema)(e))return`standard-schema`;if(n.m(e))return`json-schema`;if(n.tt(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 Y(e){let t=P(e);return n.Y(t)||n.K(t)?t.variant:(0,o.isSetString)(t)||n.p(t)?`file-reference`:J(t)}async function X(e,t){if(n.Y(e))return e.schema;let r=t??J(e),i;if((r===`zod3`||r===`json-schema`||r===`standard-schema`||r===`untyped`||r===`valibot`)&&(i=q(e)),i)return B(i);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 Z(e,t){if(e===`zod3`)return{hash:K(e,t),variant:`zod3`,schema:t};if(e===`untyped`)return{hash:K(e,t),variant:`untyped`,schema:t};if(e===`standard-schema`)return{hash:K(e,t),variant:`standard-schema`,schema:t};if(e===`json-schema`)return{hash:K(e,t),variant:`json-schema`,schema:t};if(e===`valibot`)return{hash:K(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 Q(e,t={}){let n=(0,s.extractFileReference)(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(0,c.resolveSafe)(n.file,{fs:t.fs}),a=i||n.file;try{return(0,te.createGenerator)({path:a,type:r,expose:`all`,jsDoc:`extended`,markdownDescription:!0,fullDescription:!0,skipTypeCheck:!0,tsProgram:M(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 i=P(e);if(n.Y(i))return i;if(n.K(i))return{...i,source:{hash:K(`json-schema`,i.schema),variant:`json-schema`,schema:i.schema}};let a,o=Y(i),c=K(o,i);if(o===`file-reference`){let e=(0,s.extractFileReference)(i);if(!e)throw Error(`Failed to extract a valid file reference from the provided input "${JSON.stringify(i)}". 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 o=(0,f.findFileExtensionSafe)(e.file);if(o&&!p.VALID_OBJECT_SOURCE_EXTENSIONS.includes(o))throw Error(`The provided schema file input "${e.file}" has an invalid file extension (.${o}). Please ensure that the file has one of the following extensions: ${(0,h.list)(p.VALID_OBJECT_SOURCE_EXTENSIONS,{conjunction:`or`})}.`);let c;t.storage&&(c=r.t(t.storage));let l=await(0,m.loadSafe)(i,{...t,fs:c});l??=await Q(i,{...t,fs:c});let u=P(l);a=n.Y(u)?u.source:n.K(u)?{hash:K(`json-schema`,u.schema),variant:`json-schema`,schema:u.schema}:Z(J(u),u)}else if([`json-schema`,`standard-schema`,`zod3`,`untyped`,`valibot`,`reflection`].includes(o))a=Z(o,i);else throw Error(`Invalid schema definition input "${o}". The variant must be one of "file-reference", "json-schema", "standard-schema", "zod3", "valibot", "untyped", or "reflection".`);return{variant:o,source:a,schema:await X(a.schema,a.variant),hash:c}}async function oe(e,t={}){let r=P(e);if(n.Y(r)||n.J(r))return r;let i=await $(e,t);if(!i?.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 i}exports.JSON_SCHEMA_METADATA_KEYS=t.t,exports.JSON_SCHEMA_PRIMITIVE_TYPES=t.n,exports.JSON_SCHEMA_TYPES=t.r,exports.JsonSchemaTypeNames=t.i,exports.SCHEMA_ARRAY_CONCAT_KEYWORDS=t.a,exports.SCHEMA_RECORD_KEYWORDS=t.o,exports.SCHEMA_SINGLE_KEYWORDS=t.s,exports.addProperty=n.t,exports.applyJsonSchemaMetadata=n.nt,exports.assertSchemasDoNotContradict=T,exports.bundleReferences=B,exports.createStoragePromises=r.n,exports.extract=oe,exports.extractHash=K,exports.extractJsonSchema=q,exports.extractResolvedVariant=J,exports.extractSchema=X,exports.extractSchemaWithSource=$,exports.extractSource=Z,exports.extractTSType=Q,exports.extractVariant=Y,exports.findSchemaContradictions=w,exports.getJsonSchema=n.n,exports.getJsonSchemaObject=n.r,exports.getPrimarySchemaType=n.rt,exports.getProperties=n.i,exports.getPropertiesList=n.a,exports.getProperty=n.o,exports.isFileReference=n.p,exports.isJsonSchema=n.m,exports.isJsonSchemaAllOf=n.h,exports.isJsonSchemaAny=n.g,exports.isJsonSchemaAnyOf=n._,exports.isJsonSchemaArray=n.v,exports.isJsonSchemaBigint=n.y,exports.isJsonSchemaBoolean=n.b,exports.isJsonSchemaDate=n.x,exports.isJsonSchemaDecimal=n.S,exports.isJsonSchemaEnum=n.C,exports.isJsonSchemaInteger=n.w,exports.isJsonSchemaKeywords=n.T,exports.isJsonSchemaLiteral=n.E,exports.isJsonSchemaMap=n.D,exports.isJsonSchemaNativeEnum=n.O,exports.isJsonSchemaNever=n.k,exports.isJsonSchemaNull=n.A,exports.isJsonSchemaNullable=n.j,exports.isJsonSchemaNumber=n.M,exports.isJsonSchemaObject=n.N,exports.isJsonSchemaPrimitiveType=n.P,exports.isJsonSchemaPrimitiveUnion=n.F,exports.isJsonSchemaRecord=n.I,exports.isJsonSchemaRef=n.L,exports.isJsonSchemaSet=n.R,exports.isJsonSchemaString=n.z,exports.isJsonSchemaTuple=n.B,exports.isJsonSchemaType=n.V,exports.isJsonSchemaUndefined=n.H,exports.isJsonSchemaUnion=n.U,exports.isJsonSchemaUnknown=n.W,exports.isNullOnlyJsonSchema=n.G,exports.isPropertyOptional=n.s,exports.isSchema=n.K,exports.isSchemaNullable=n.c,exports.isSchemaObject=n.q,exports.isSchemaOf=n.J,exports.isSchemaWithSource=n.Y,exports.isStandardSchema=n.X,exports.isUntypedConfig=n.Z,exports.isUntypedConfigStrict=n.Q,exports.isUntypedSchema=n.$,exports.isUntypedSchemaStrict=n.et,exports.isValibotSchema=n.tt,exports.isValidSchemaConfigFile=n.l,exports.mapStorageToFileSystem=r.t,exports.merge=n.u,exports.mergeMetadata=n.d,exports.normalizeKey=r.r,exports.readSchemaTypes=n.it,exports.traverseSchema=n.f;
+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_storage = require('./storage-B8aDmNpv.cjs');
+let _stryke_type_checks_is_set_object = require("@stryke/type-checks/is-set-object");
+let _stryke_type_checks_is_set_string = require("@stryke/type-checks/is-set-string");
+let _stryke_type_checks = require("@stryke/type-checks");
+let _stryke_convert_extract_file_reference = require("@stryke/convert/extract-file-reference");
+let _stryke_fs_resolve = require("@stryke/fs/resolve");
+let _stryke_hash = require("@stryke/hash");
+let _stryke_helpers_deep_clone = require("@stryke/helpers/deep-clone");
+let _stryke_json = require("@stryke/json");
+let _stryke_path_find = require("@stryke/path/find");
+let _stryke_resolve_constants = require("@stryke/resolve/constants");
+let _stryke_resolve_load = require("@stryke/resolve/load");
+let _stryke_string_format_list = require("@stryke/string-format/list");
+let _stryke_zod = require("@stryke/zod");
+let _typescript_vfs = require("@typescript/vfs");
+let _valibot_to_json_schema = require("@valibot/to-json-schema");
+let node_path = require("node:path");
+let ts_json_schema_generator_dist_factory_generator_js = require("ts-json-schema-generator/dist/factory/generator.js");
+let typescript = require("typescript");
+typescript = require_rolldown_runtime.__toESM(typescript, 1);
+
+//#region src/compatibility.ts
+const METADATA_KEYS = /* @__PURE__ */ new Set([
+	...require_constants.JSON_SCHEMA_METADATA_KEYS,
+	"default",
+	"examples"
+]);
+function isMetadataKey(key) {
+	return METADATA_KEYS.has(key);
+}
+function isUnconstrainedSchema(schema) {
+	if (!(0, _stryke_type_checks_is_set_object.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 ((0, _stryke_type_checks_is_set_string.isSetString)(schemaType)) return [schemaType];
+	if (Array.isArray(schemaType)) return schemaType.filter(_stryke_type_checks_is_set_string.isSetString);
+	const primitiveTypes = require_helpers.readSchemaTypes(schema);
+	if (primitiveTypes.length > 0) return primitiveTypes;
+	if (require_helpers.isJsonSchemaObject(schema)) return ["object"];
+	if (require_helpers.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 (require_helpers.isJsonSchemaObject(base) && require_helpers.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 && require_helpers.isJsonSchema(baseProperty) && require_helpers.isJsonSchema(overrideProperty)) issues.push(...findSchemaContradictions(baseProperty, overrideProperty, propertyPath));
+		}
+	}
+	if (require_helpers.isJsonSchemaArray(base) && require_helpers.isJsonSchemaArray(override)) {
+		const baseItems = base.items;
+		const overrideItems = override.items;
+		if (baseItems && overrideItems && require_helpers.isJsonSchema(baseItems) && require_helpers.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 (require_helpers.isJsonSchema(baseItem) && require_helpers.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: typescript.default.ScriptTarget.ES2022,
+	module: typescript.default.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) ?? typescript.default.sys.readFile(tsconfig);
+	if (!raw) return { ...DEFAULT_TS_COMPILER_OPTIONS };
+	const parsed = typescript.default.parseConfigFileTextToJson(tsconfig, raw);
+	if (!parsed.config) return { ...DEFAULT_TS_COMPILER_OPTIONS };
+	const options = {
+		...typescript.default.parseJsonConfigFileContent(parsed.config, system, (0, node_path.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 ?? (0, node_path.dirname)(rootFile);
+	const createSystem = _typescript_vfs.createFSBackedSystem;
+	const createHost = _typescript_vfs.createVirtualCompilerHost;
+	const system = createSystem(/* @__PURE__ */ new Map(), projectRoot, typescript.default);
+	if (options.fs) bindFileSystemToSystem(system, options.fs);
+	const compilerOptions = resolveCompilerOptions(system, options.tsconfig, options.fs);
+	const { compilerHost } = createHost(system, compilerOptions, typescript.default);
+	return typescript.default.createProgram({
+		rootNames: [rootFile],
+		options: compilerOptions,
+		host: compilerHost
+	});
+}
+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;
+	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 (!(0, _stryke_type_checks_is_set_object.isSetObject)(value)) return;
+	const schema = value;
+	const pointer = toJsonPointer(path);
+	const currentBaseUri = (0, _stryke_type_checks.isSetString)(schema.$id) ? resolveUri(schema.$id, baseUri) : baseUri;
+	const currentDocumentUri = stripUriFragment(currentBaseUri);
+	uriToPointer.set(currentBaseUri, pointer);
+	uriToPointer.set(currentDocumentUri, pointer);
+	if ((0, _stryke_type_checks.isSetString)(schema.$anchor)) uriToPointer.set(`${currentDocumentUri}#${schema.$anchor}`, pointer);
+	if ((0, _stryke_type_checks.isSetString)(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 (!(0, _stryke_type_checks_is_set_object.isSetObject)(value)) return;
+	const schema = value;
+	const currentBaseUri = (0, _stryke_type_checks.isSetString)(schema.$id) ? resolveUri(schema.$id, baseUri) : baseUri;
+	if ((0, _stryke_type_checks.isSetString)(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 ((0, _stryke_type_checks.isSetString)(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 (!(0, _stryke_type_checks_is_set_object.isSetObject)(schema)) return schema;
+	const bundledSchema = (0, _stryke_helpers_deep_clone.deepClone)(schema);
+	const baseUri = (0, _stryke_type_checks.isSetString)(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 (require_helpers.isUntypedSchema(value)) return convertUntypedSchemaToJsonSchema(value);
+	if ((0, _stryke_type_checks_is_set_object.isSetObject)(value)) {
+		if (require_helpers.isUntypedConfig(value)) return convertUntypedConfigToJsonSchema(value);
+		const nested = value;
+		if ("$schema" in nested && require_helpers.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 (0, _valibot_to_json_schema.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" && (0, _stryke_type_checks.isSetString)(value)) {
+			jsonSchema.$id = value;
+			continue;
+		}
+		if (key === "properties" || key === "patternProperties" || key === "dependentSchemas" || key === "$defs" || key === "definitions") {
+			if (!(0, _stryke_type_checks_is_set_object.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 = require_helpers.isUntypedSchema(inputObject.$schema) ? convertUntypedSchemaToJsonSchema(inputObject.$schema) : {};
+	const properties = {};
+	for (const [key, value] of Object.entries(inputObject)) {
+		if (key.startsWith("$")) continue;
+		if (!(0, _stryke_type_checks_is_set_object.isSetObject)(value)) continue;
+		if (require_helpers.isUntypedConfig(value)) {
+			properties[key] = convertUntypedConfigToJsonSchema(value);
+			continue;
+		}
+		const nested = value;
+		if ("$schema" in nested && require_helpers.isUntypedSchema(nested.$schema)) {
+			properties[key] = convertUntypedSchemaToJsonSchema(nested.$schema);
+			continue;
+		}
+		if (require_helpers.isUntypedSchema(value)) properties[key] = convertUntypedSchemaToJsonSchema(value);
+	}
+	if (!require_helpers.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 = {
+		...(0, _stryke_type_checks_is_set_object.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 (require_helpers.isSchemaWithSource(unwrappedConfig) || require_helpers.isSchema(unwrappedConfig)) return (0, _stryke_hash.murmurhash)({
+		variant,
+		input: unwrappedConfig.schema
+	});
+	if ((0, _stryke_type_checks.isSetString)(unwrappedConfig)) return (0, _stryke_hash.murmurhash)({
+		variant,
+		input: unwrappedConfig
+	});
+	else if (typeof unwrappedConfig === "boolean") return (0, _stryke_hash.murmurhash)({
+		variant,
+		input: unwrappedConfig
+	});
+	else if ((0, _stryke_type_checks_is_set_object.isSetObject)(unwrappedConfig)) {
+		if ((0, _stryke_zod.isZod3Type)(unwrappedConfig)) return (0, _stryke_hash.murmurhash)({
+			variant,
+			input: unwrappedConfig._def
+		});
+		else if ((0, _stryke_json.isStandardJsonSchema)(unwrappedConfig)) return (0, _stryke_hash.murmurhash)({
+			variant,
+			input: unwrappedConfig["~standard"]
+		});
+		else if (require_helpers.isJsonSchema(unwrappedConfig)) return (0, _stryke_hash.murmurhash)({
+			variant,
+			input: unwrappedConfig
+		});
+		else if (require_helpers.isValibotSchema(unwrappedConfig)) return (0, _stryke_hash.murmurhash)({
+			variant,
+			input: convertValibotSchemaToJsonSchema(unwrappedConfig)
+		});
+		else if (require_helpers.isUntypedConfig(unwrappedConfig)) return (0, _stryke_hash.murmurhash)({
+			variant,
+			input: convertUntypedConfigToJsonSchema(unwrappedConfig)
+		});
+		else if (require_helpers.isUntypedSchema(unwrappedConfig)) return (0, _stryke_hash.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 ((0, _stryke_type_checks_is_set_object.isSetObject)(schema)) {
+		if ((0, _stryke_zod.isZod3Type)(schema)) return (0, _stryke_zod.extractJsonSchema)(schema, { target: "draft-2020-12" });
+		if (require_helpers.isUntypedConfigStrict(schema)) return convertUntypedConfigToJsonSchema(schema);
+		if (require_helpers.isUntypedSchemaStrict(schema)) return convertUntypedSchemaToJsonSchema(schema);
+		if ((0, _stryke_json.isStandardJsonSchema)(schema)) return schema["~standard"].jsonSchema.input({ target: "draft-2020-12" });
+		if (require_helpers.isValibotSchema(schema)) return convertValibotSchemaToJsonSchema(schema);
+		if (require_helpers.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 ((0, _stryke_type_checks_is_set_object.isSetObject)(input)) {
+		if ((0, _stryke_zod.isZod3Type)(input)) return "zod3";
+		else if (require_helpers.isUntypedConfigStrict(input) || require_helpers.isUntypedSchemaStrict(input)) return "untyped";
+		else if ((0, _stryke_json.isStandardJsonSchema)(input)) return "standard-schema";
+		else if (require_helpers.isJsonSchema(input)) return "json-schema";
+		else if (require_helpers.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 (require_helpers.isSchemaWithSource(unwrappedConfig) || require_helpers.isSchema(unwrappedConfig)) return unwrappedConfig.variant;
+	if ((0, _stryke_type_checks.isSetString)(unwrappedConfig) || require_helpers.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 (require_helpers.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 = (0, _stryke_convert_extract_file_reference.extractFileReference)(input);
+	if (!fileReference) throw new Error(`Failed to extract a file reference from the provided input. The input must be a string or an object with a "file" property that specifies the file path and optional export name.`);
+	const exportName = fileReference.export ?? "*";
+	const resolvedPath = await (0, _stryke_fs_resolve.resolveSafe)(fileReference.file, { fs: options.fs });
+	const filePath = resolvedPath || fileReference.file;
+	try {
+		return (0, ts_json_schema_generator_dist_factory_generator_js.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 (require_helpers.isSchemaWithSource(unwrappedConfig)) return unwrappedConfig;
+	if (require_helpers.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 = (0, _stryke_convert_extract_file_reference.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 = (0, _stryke_path_find.findFileExtensionSafe)(fileReference.file);
+		if (extension && !_stryke_resolve_constants.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: ${(0, _stryke_string_format_list.list)(_stryke_resolve_constants.VALID_OBJECT_SOURCE_EXTENSIONS, { conjunction: "or" })}.`);
+		let fs;
+		if (options.storage) fs = require_storage.mapStorageToFileSystem(options.storage);
+		let resolved = await (0, _stryke_resolve_load.loadSafe)(unwrappedConfig, {
+			...options,
+			fs
+		});
+		resolved ??= await extractTSType(unwrappedConfig, {
+			...options,
+			fs
+		});
+		const resolvedConfig = unwrapSchemaConfig(resolved);
+		if (require_helpers.isSchemaWithSource(resolvedConfig)) source = resolvedConfig.source;
+		else if (require_helpers.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 (require_helpers.isSchemaWithSource(unwrappedConfig) || require_helpers.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
+exports.JSON_SCHEMA_METADATA_KEYS = require_constants.JSON_SCHEMA_METADATA_KEYS;
+exports.JSON_SCHEMA_PRIMITIVE_TYPES = require_constants.JSON_SCHEMA_PRIMITIVE_TYPES;
+exports.JSON_SCHEMA_TYPES = require_constants.JSON_SCHEMA_TYPES;
+exports.JsonSchemaTypeNames = require_constants.JsonSchemaTypeNames;
+exports.SCHEMA_ARRAY_CONCAT_KEYWORDS = require_constants.SCHEMA_ARRAY_CONCAT_KEYWORDS;
+exports.SCHEMA_RECORD_KEYWORDS = require_constants.SCHEMA_RECORD_KEYWORDS;
+exports.SCHEMA_SINGLE_KEYWORDS = require_constants.SCHEMA_SINGLE_KEYWORDS;
+exports.addProperty = require_helpers.addProperty;
+exports.applyJsonSchemaMetadata = require_helpers.applyJsonSchemaMetadata;
+exports.assertSchemasDoNotContradict = assertSchemasDoNotContradict;
+exports.bundleReferences = bundleReferences;
+exports.createStoragePromises = require_storage.createStoragePromises;
+exports.extract = extract;
+exports.extractHash = extractHash;
+exports.extractJsonSchema = extractJsonSchema;
+exports.extractResolvedVariant = extractResolvedVariant;
+exports.extractSchema = extractSchema;
+exports.extractSchemaWithSource = extractSchemaWithSource;
+exports.extractSource = extractSource;
+exports.extractTSType = extractTSType;
+exports.extractVariant = extractVariant;
+exports.findSchemaContradictions = findSchemaContradictions;
+exports.getJsonSchema = require_helpers.getJsonSchema;
+exports.getJsonSchemaObject = require_helpers.getJsonSchemaObject;
+exports.getPrimarySchemaType = require_helpers.getPrimarySchemaType;
+exports.getProperties = require_helpers.getProperties;
+exports.getPropertiesList = require_helpers.getPropertiesList;
+exports.getProperty = require_helpers.getProperty;
+exports.isFileReference = require_helpers.isFileReference;
+exports.isJsonSchema = require_helpers.isJsonSchema;
+exports.isJsonSchemaAllOf = require_helpers.isJsonSchemaAllOf;
+exports.isJsonSchemaAny = require_helpers.isJsonSchemaAny;
+exports.isJsonSchemaAnyOf = require_helpers.isJsonSchemaAnyOf;
+exports.isJsonSchemaArray = require_helpers.isJsonSchemaArray;
+exports.isJsonSchemaBigint = require_helpers.isJsonSchemaBigint;
+exports.isJsonSchemaBoolean = require_helpers.isJsonSchemaBoolean;
+exports.isJsonSchemaDate = require_helpers.isJsonSchemaDate;
+exports.isJsonSchemaDecimal = require_helpers.isJsonSchemaDecimal;
+exports.isJsonSchemaEnum = require_helpers.isJsonSchemaEnum;
+exports.isJsonSchemaInteger = require_helpers.isJsonSchemaInteger;
+exports.isJsonSchemaKeywords = require_helpers.isJsonSchemaKeywords;
+exports.isJsonSchemaLiteral = require_helpers.isJsonSchemaLiteral;
+exports.isJsonSchemaMap = require_helpers.isJsonSchemaMap;
+exports.isJsonSchemaNativeEnum = require_helpers.isJsonSchemaNativeEnum;
+exports.isJsonSchemaNever = require_helpers.isJsonSchemaNever;
+exports.isJsonSchemaNull = require_helpers.isJsonSchemaNull;
+exports.isJsonSchemaNullable = require_helpers.isJsonSchemaNullable;
+exports.isJsonSchemaNumber = require_helpers.isJsonSchemaNumber;
+exports.isJsonSchemaObject = require_helpers.isJsonSchemaObject;
+exports.isJsonSchemaPrimitiveType = require_helpers.isJsonSchemaPrimitiveType;
+exports.isJsonSchemaPrimitiveUnion = require_helpers.isJsonSchemaPrimitiveUnion;
+exports.isJsonSchemaRecord = require_helpers.isJsonSchemaRecord;
+exports.isJsonSchemaRef = require_helpers.isJsonSchemaRef;
+exports.isJsonSchemaSet = require_helpers.isJsonSchemaSet;
+exports.isJsonSchemaString = require_helpers.isJsonSchemaString;
+exports.isJsonSchemaTuple = require_helpers.isJsonSchemaTuple;
+exports.isJsonSchemaType = require_helpers.isJsonSchemaType;
+exports.isJsonSchemaUndefined = require_helpers.isJsonSchemaUndefined;
+exports.isJsonSchemaUnion = require_helpers.isJsonSchemaUnion;
+exports.isJsonSchemaUnknown = require_helpers.isJsonSchemaUnknown;
+exports.isNullOnlyJsonSchema = require_helpers.isNullOnlyJsonSchema;
+exports.isPropertyOptional = require_helpers.isPropertyOptional;
+exports.isSchema = require_helpers.isSchema;
+exports.isSchemaNullable = require_helpers.isSchemaNullable;
+exports.isSchemaObject = require_helpers.isSchemaObject;
+exports.isSchemaOf = require_helpers.isSchemaOf;
+exports.isSchemaWithSource = require_helpers.isSchemaWithSource;
+exports.isStandardSchema = require_helpers.isStandardSchema;
+exports.isUntypedConfig = require_helpers.isUntypedConfig;
+exports.isUntypedConfigStrict = require_helpers.isUntypedConfigStrict;
+exports.isUntypedSchema = require_helpers.isUntypedSchema;
+exports.isUntypedSchemaStrict = require_helpers.isUntypedSchemaStrict;
+exports.isValibotSchema = require_helpers.isValibotSchema;
+exports.isValidSchemaConfigFile = require_helpers.isValidSchemaConfigFile;
+exports.mapStorageToFileSystem = require_storage.mapStorageToFileSystem;
+exports.merge = require_helpers.merge;
+exports.mergeMetadata = require_helpers.mergeMetadata;
+exports.normalizeKey = require_storage.normalizeKey;
+exports.readSchemaTypes = require_helpers.readSchemaTypes;
+exports.traverseSchema = require_helpers.traverseSchema;