@powerlines/schema 0.11.28 → 0.11.38

package/dist/extract.d.mts

@@ -1,90 +1,54 @@
-import { ExtractedSchema, JTDSchemaType, Schema, SchemaInput, SchemaInputVariant, SchemaMetadata, SchemaSource, SchemaSourceInput, SchemaSourceVariant } from "./types.mjs";
-import { BuildOptions } from "esbuild";
+import { ExtractedSchema, JsonSchema, Schema, SchemaInput, SchemaInputVariant, SchemaSource, SchemaSourceInput, SchemaSourceVariant } from "./types.mjs";
+import { BuildOptions } from "rolldown";
 import { Context } from "@powerlines/core";
 import { Type } from "@powerlines/deepkit/vendor/type";
 
 //#region src/extract.d.ts
 /**
- * Creates a hash string for a given schema definition input. The function checks the type of the input and generates a hash based on its content. If the input is a Zod schema, it hashes the JSON representation of its internal definition. If the input is a Standard JSON Schema, it hashes the JSON representation of its internal standard schema. If the input is already a JSON Schema object, it hashes its JSON representation directly. If the input is a reflected Deepkit Type object, it hashes its JSON representation. The resulting hash string can be used for caching or comparison purposes.
+ * Creates a hash string for a given schema definition input.
  */
-declare function extractHash(variant: SchemaInputVariant, input: SchemaInput): string;
+declare function extractHash<T = unknown>(variant: SchemaInputVariant, input: SchemaInput<T>): string;
 /**
- * Converts a reflected Deepkit {@link @powerlines/deepkit/vendor/type#Type} into a JSON Schema (draft-07) representation.
- *
- * @remarks
- * This function delegates to an internal recursive walker that handles the full set of Deepkit reflection kinds.
- *
- * @param reflection - The reflected Deepkit Type to convert.
- * @returns A JSON Schema (draft-07) fragment representing the type, or `undefined` when no schema could be produced.
+ * Converts a reflected Deepkit {@link Type} into a JSON Schema (draft-07) representation.
  */
-declare function extractReflection<TMetadata extends Partial<SchemaMetadata> = Partial<SchemaMetadata>>(reflection: Type): JTDSchemaType<TMetadata> | undefined;
+declare function extractReflection<T = unknown>(reflection: Type): JsonSchema<T> | undefined;
 /**
- * Extracts a JSON Type Definition (RFC 8927) schema from a given schema definition, if possible.
- *
- * @remarks
- * This function checks if the provided input is a Zod schema, a Standard JSON Schema, or already a JSON Schema object, extracts a JSON Schema fragment via the appropriate adapter (Zod and Standard Schema produce draft-07 fragments), and then converts that fragment into a valid JTD form suitable for AJV's JTD validator.
- *
- * @param schema - The schema definition to extract from. This can be a Zod schema, a Standard JSON Schema, or a JSON Schema object.
- * @returns The extracted JTD schema if successful, otherwise undefined.
- */
-declare function extractJsonSchema<TMetadata extends Partial<SchemaMetadata> = Partial<SchemaMetadata>>(schema: unknown): JTDSchemaType<TMetadata> | undefined;
-/**
- * Extracts a schema definition from a given input object, which can be a Zod schema, a Standard JSON Schema, a JSON Schema object, or a reflected Deepkit Type object. The function checks the type of the input and attempts to extract the corresponding schema based on its variant. If the input is a Zod schema, it extracts the JSON Schema using the `extractJsonSchema` function. If the input is a Standard JSON Schema, it retrieves the JSON Schema targeting draft-07. If the input is already a JSON Schema object, it uses it directly. If the input is a reflected Deepkit Type object, it extracts the schema using the `extractReflection` function. The function returns a `Schema` containing the extracted schema and its variant if successful; otherwise, it throws an error.
- *
- * @param input - The input object to extract the schema definition from.
- * @returns A `Schema` containing the extracted schema and its variant if successful.
- * @throws An error if the input does not contain a valid schema definition.
+ * Extracts a JSON Schema from Zod, Standard Schema, untyped, or JSON Schema inputs.
  */
+declare function extractJsonSchema<T = unknown>(schema: unknown): JsonSchema<T> | undefined;
 declare function extractResolvedVariant(input: SchemaSourceInput): SchemaSourceVariant;
+declare function extractVariant<T = unknown>(input: SchemaInput<T>): SchemaInputVariant;
+declare function extractSchemaSchema<T = unknown>(input: SchemaSourceInput, variant?: SchemaInputVariant): Promise<JsonSchema<T>>;
+declare function extractSource(variant: SchemaSourceVariant, input: SchemaSourceInput): SchemaSource;
 /**
- * Extracts a schema definition from a given input object, which can be a Zod schema, a Standard JSON Schema, a JSON Schema object, a reflected Deepkit Type object, or an Untyped schema. The function checks the type of the input and attempts to extract the corresponding schema based on its variant. If the input is a Zod schema, it extracts the JSON Schema using the `extractJsonSchema` function. If the input is a Standard JSON Schema, it retrieves the JSON Schema targeting draft-07. If the input is already a JSON Schema object, it uses it directly. If the input is a reflected Deepkit Type object, it extracts the schema using the `extractReflection` function. The function returns a `Schema` containing the extracted schema and its variant if successful; otherwise, it throws an error.
- *
- * @param input - The input object to extract the schema definition from.
- * @returns A `Schema` containing the extracted schema and its variant if successful.
- * @throws An error if the input does not contain a valid schema definition.
- */
-declare function extractVariant(input: SchemaInput): SchemaInputVariant;
-/**
- * Extracts a JSON Schema object from a given schema definition input. The input can be a Zod schema, a Standard JSON Schema, a JSON Schema object, or a reflected Deepkit Type object. The function checks the type of the input and attempts to extract the corresponding JSON Schema based on its variant. If the input is a Zod schema, it extracts the JSON Schema using the `extractJsonSchema` function. If the input is a Standard JSON Schema, it retrieves the JSON Schema targeting draft-07. If the input is already a JSON Schema object, it uses it directly. If the input is a reflected Deepkit Type object, it extracts the schema using the `extractReflection` function. The function returns the extracted JSON Schema if successful; otherwise, it throws an error.
- *
- * @param input - The schema definition input to extract the JSON Schema from. This can be a Zod schema, a Standard JSON Schema, a JSON Schema object, or a TypeScript type definition.
- * @param variant - The variant of the schema definition to extract.
- * @returns The extracted JSON Schema if successful.
- * @throws An error if the input does not contain a valid schema definition.
- */
-declare function extractSchemaSchema<TMetadata extends Partial<SchemaMetadata> = Partial<SchemaMetadata>>(input: SchemaSourceInput, variant?: SchemaInputVariant): Promise<JTDSchemaType<TMetadata>>;
-/**
- * Extracts a schema definition from a given input object, which can be a Zod schema, a Standard JSON Schema, a JSON Schema object, a JTD schema, an untyped schema, or a reflected Deepkit Type object. The function checks the type of the input and attempts to extract the corresponding schema based on its variant. If the input is a Zod schema, it extracts the JSON Schema using the `extractJsonSchema` function. If the input is a Standard JSON Schema, it retrieves the JSON Schema targeting draft-07. If the input is already a JSON Schema object, it uses it directly. If the input is a reflected Deepkit Type object, it extracts the schema using the `extractReflection` function. The function returns a `Schema` containing the extracted schema and its variant if successful; otherwise, it throws an error.
- *
- * @param variant - The variant of the schema definition to extract.
- * @param input - The input object to extract the schema definition from.
- * @returns A `Schema` containing the extracted schema and its variant if successful.
- * @throws An error if the input does not contain a valid schema definition.
- */
-declare function extractSource<TMetadata extends Partial<SchemaMetadata> = Partial<SchemaMetadata>>(variant: SchemaSourceVariant, input: SchemaSourceInput): SchemaSource;
-/**
- * Resolves the provided entry points to their corresponding type definitions. The function accepts an array of entry points, which can be strings (file paths) or type definition objects. It processes each entry point, resolving file paths and glob patterns to find matching files. For each resolved file, it creates a type definition object and resolves it using the `resolveInput` function. The function returns an array of resolved entry type definitions.
+ * Extracts a JSON Schema from a given schema definition input, which can be a Zod schema, a Standard JSON Schema, a JSON Schema object, an untyped schema, or a reflected Deepkit Type object. If the input is a type definition reference (e.g. a file path with an export), it will be resolved and bundled using ESBuild to obtain the actual schema definition before extraction.
  *
  * @example
  * ```ts
  * // Resolve a schema definition from a file path
- * const schema1 = await extractSchema(context, "./schemas.ts#MySchema");
+ * const schema1 = await extract(context, "./schemas.ts#MySchema");
  * // Resolve a schema definition from a JSON Schema object
- * const schema2 = await extractSchema(context, schemaObject);
+ * const schema2 = await extract(context, schemaObject);
  * // Resolve a schema definition from a Zod schema
- * const schema3 = await extractSchema(context, zodSchema);
+ * const schema3 = await extract(context, zodSchema);
  * // Resolve a schema definition from a reflected Deepkit Type object
- * const schema4 = await extractSchema(context, reflectionType);
+ * const schema4 = await extract(context, reflectionType);
  * ```
  *
- * @param context - The plugin context used for resolving the schema definition input.
- * @param input - The schema definition input to extract the JSON Schema from. This can be a Zod schema, a Standard JSON Schema, a JSON Schema object, or a TypeScript type definition.
- * @param options - Optional overrides for the ESBuild configuration used during resolution.
- * @returns A promise that resolves to a {@link ExtractedSchema} containing the extracted JSON Schema and its variant, or the bytecode if JSON Schema extraction is not possible.
+ * @see https://github.com/colinhacks/zod
+ * @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://deepkit.io/en/documentation/runtime-types/reflection
+ *
+ * @param context - The context object providing access to the file system and cache path.
+ * @param input - The schema definition input to extract, which can be a Zod schema, a Standard JSON Schema, a JSON Schema object, an untyped schema, or a reflected Deepkit Type object. If the input is a string or a type definition reference, it will be resolved and bundled to obtain the actual schema definition before extraction.
+ * @param options - Optional overrides for the ESBuild configuration used during extraction. This can include custom plugins, loaders, or other build options to control how the schema definition is resolved and bundled when the input is a type definition reference.
+ * @returns A promise that resolves to the extracted and normalized schema as a JSON Schema object. The function will attempt to extract a valid JSON Schema from the provided input, and if successful, it will return the schema. If the extraction process fails or if the input is not a valid schema definition, it will throw an error indicating the failure.
  */
-declare function extractSchema<TMetadata extends Partial<SchemaMetadata> = Partial<SchemaMetadata>, TContext extends Context = Context>(context: TContext, input: SchemaInput, options?: Partial<BuildOptions>): Promise<ExtractedSchema<TMetadata>>;
+declare function extractSchema<T = unknown>(context: Context, input: SchemaInput, options?: Partial<BuildOptions>): Promise<ExtractedSchema<T>>;
 /**
- * Resolves the provided entry points to their corresponding type definitions. The function accepts an array of entry points, which can be strings (file paths) or type definition objects. It processes each entry point, resolving file paths and glob patterns to find matching files. For each resolved file, it creates a type definition object and resolves it using the `resolveInput` function. The function returns an array of resolved entry type definitions.
+ * Extracts a JSON Schema from a given schema definition input, which can be a Zod schema, a Standard JSON Schema, a JSON Schema object, an untyped schema, or a reflected Deepkit Type object. If the input is a type definition reference (e.g. a file path with an export), it will be resolved and bundled using ESBuild to obtain the actual schema definition before extraction.
  *
  * @example
  * ```ts
@@ -106,12 +70,13 @@ declare function extractSchema<TMetadata extends Partial<SchemaMetadata> = Parti
  * @see https://github.com/unjs/untyped
  * @see https://www.typescriptlang.org/docs/handbook/2/types-from-types.html
  *
- * @param context - The {@link Context | context} used for resolving the {@link Schema | schema} definition input.
- * @param input - The input object or string to extract the {@link Schema | schema} from. This can be {@link TypeDefinitionReference | a string that references a Typescript module}, a [Zod v3 schema](https://github.com/colinhacks/zod), any type that adheres to [the Standard JSON Schema specification](https://standardschema.dev/json-schema#what-schema-libraries-support-this-spec), a [JSON Schema object](https://json-schema.org/), a [JTD schema object](https://ajv.js.org/json-type-definition.html), an [untyped schema](https://github.com/unjs/untyped), or a [TypeScript type reflection](https://deepkit.io/en/documentation/runtime-types/reflection).
- * @param options - Optional overrides for the [ESBuild configuration](https://esbuild.github.io/api/#general-options) used during resolution.
- * @returns A promise that resolves to a {@link Schema | schema} object parsed from the input.
+ * @param context - The context object providing access to the file system and cache path.
+ * @param input - The schema definition input to extract, which can be a Zod schema, a Standard JSON Schema, a JSON Schema object, an untyped schema, or a reflected Deepkit Type object.
+ * @param options - Optional overrides for the ESBuild 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.
  */
-declare function extract<TMetadata extends Partial<SchemaMetadata> = Partial<SchemaMetadata>, TContext extends Context = Context>(context: TContext, input: SchemaInput, options?: Partial<BuildOptions>): Promise<Schema<TMetadata>>;
+declare function extract<T = unknown>(context: Context, input: SchemaInput, options?: Partial<BuildOptions>): Promise<Schema<T>>;
 //#endregion
 export { extract, extractHash, extractJsonSchema, extractReflection, extractResolvedVariant, extractSchema, extractSchemaSchema, extractSource, extractVariant };
 //# sourceMappingURL=extract.d.mts.map

package/dist/extract.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"extract.d.mts","names":[],"sources":["../src/extract.ts"],"mappings":";;;;;;;;AAmEA;iBAAgB,WAAA,CACd,OAAA,EAAS,kBAAA,EACT,KAAA,EAAO,WAAA;;;;;;;;;AA8BT;iBAAgB,iBAAA,mBACI,OAAA,CAAQ,cAAA,IAAkB,OAAA,CAAQ,cAAA,EAAA,CACpD,UAAA,EAAY,IAAA,GAAO,aAAA,CAAc,SAAA;;;;;;;;;;iBAiBnB,iBAAA,mBACI,OAAA,CAAQ,cAAA,IAAkB,OAAA,CAAQ,cAAA,EAAA,CACpD,MAAA,YAAkB,aAAA,CAAc,SAAA;;;;;;;;iBAsClB,sBAAA,CACd,KAAA,EAAO,iBAAA,GACN,mBAAA;;;;AA1CH;;;;iBAuEgB,cAAA,CAAe,KAAA,EAAO,WAAA,GAAc,kBAAA;;;;;;;;;iBAgB9B,mBAAA,mBACF,OAAA,CAAQ,cAAA,IAAkB,OAAA,CAAQ,cAAA,EAAA,CAEpD,KAAA,EAAO,iBAAA,EACP,OAAA,GAAU,kBAAA,GACT,OAAA,CAAQ,aAAA,CAAc,SAAA;;;;;;;;AApDzB;iBA6FgB,aAAA,mBACI,OAAA,CAAQ,cAAA,IAAkB,OAAA,CAAQ,cAAA,EAAA,CACpD,OAAA,EAAS,mBAAA,EAAqB,KAAA,EAAO,iBAAA,GAAoB,YAAA;;;;;;;;AAhE3D;;;;;;;;;AAgBA;;;;iBAgHsB,aAAA,mBACF,OAAA,CAAQ,cAAA,IAAkB,OAAA,CAAQ,cAAA,oBACnC,OAAA,GAAU,OAAA,CAAA,CAE3B,OAAA,EAAS,QAAA,EACT,KAAA,EAAO,WAAA,EACP,OAAA,GAAS,OAAA,CAAQ,YAAA,IAChB,OAAA,CAAQ,eAAA,CAAgB,SAAA;;;;;;;;;;;;;;;;;;;;;;;;AAzE3B;;;;;iBAkKsB,OAAA,mBACF,OAAA,CAAQ,cAAA,IAAkB,OAAA,CAAQ,cAAA,oBACnC,OAAA,GAAU,OAAA,CAAA,CAE3B,OAAA,EAAS,QAAA,EACT,KAAA,EAAO,WAAA,EACP,OAAA,GAAS,OAAA,CAAQ,YAAA,IAChB,OAAA,CAAQ,MAAA,CAAO,SAAA"}
+{"version":3,"file":"extract.d.mts","names":[],"sources":["../src/extract.ts"],"mappings":";;;;;;;;AAiNA;iBAAgB,WAAA,aAAA,CACd,OAAA,EAAS,kBAAA,EACT,KAAA,EAAO,WAAA,CAAY,CAAA;;;;iBAkCL,iBAAA,aAAA,CACd,UAAA,EAAY,IAAA,GACX,UAAA,CAAW,CAAA;;;;iBAWE,iBAAA,aAAA,CACd,MAAA,YACC,UAAU,CAAC,CAAA;AAAA,iBA6BE,sBAAA,CACd,KAAA,EAAO,iBAAA,GACN,mBAAmB;AAAA,iBAoBN,cAAA,aAAA,CACd,KAAA,EAAO,WAAA,CAAY,CAAA,IAClB,kBAAA;AAAA,iBAQmB,mBAAA,aAAA,CACpB,KAAA,EAAO,iBAAA,EACP,OAAA,GAAU,kBAAA,GACT,OAAA,CAAQ,UAAA,CAAW,CAAA;AAAA,iBA4BN,aAAA,CACd,OAAA,EAAS,mBAAA,EACT,KAAA,EAAO,iBAAA,GACN,YAAA;;AAhJoB;AAkCvB;;;;;;;;;;;;;;AAEe;AAWf;;;;;;;;;iBAiKsB,aAAA,aAAA,CACpB,OAAA,EAAS,OAAA,EACT,KAAA,EAAO,WAAA,EACP,OAAA,GAAS,OAAA,CAAQ,YAAA,IAChB,OAAA,CAAQ,eAAA,CAAgB,CAAA;AAtI3B;;;;;;;;AAEsB;AAoBtB;;;;;;;;;;;;;;AAEqB;AAQrB;;;;;AAhCA,iBAiOsB,OAAA,aAAA,CACpB,OAAA,EAAS,OAAA,EACT,KAAA,EAAO,WAAA,EACP,OAAA,GAAS,OAAA,CAAQ,YAAA,IAChB,OAAA,CAAQ,MAAA,CAAO,CAAA"}

package/dist/extract.mjs

@@ -1,20 +1,91 @@
-import { jsonSchemaToJtd } from "./jtd.mjs";
+import { isExtractedSchema, isJsonSchema, isSchema, isUntypedInput, isUntypedSchema } from "./type-checks.mjs";
+import { getCacheDirectory, writeSchema } from "./persistence.mjs";
 import { reflectionToJsonSchema } from "./reflection.mjs";
 import { resolve } from "./resolve.mjs";
-import { isExtractedSchema, isJTDSchema, isSchema, isUntypedInput, isUntypedSchema } from "./type-checks.mjs";
 import defu from "defu";
+import { isSetString } from "@stryke/type-checks";
+import { isSetObject as isSetObject$1 } from "@stryke/type-checks/is-set-object";
+import { isStandardJsonSchema } from "@stryke/json";
 import { isTypeDefinition } from "@powerlines/core";
-import { esbuildPlugin } from "@powerlines/deepkit/esbuild-plugin";
+import { rolldownPlugin } from "@powerlines/deepkit/rolldown-plugin";
 import { isType, stringifyType } from "@powerlines/deepkit/vendor/type";
 import { murmurhash } from "@stryke/hash";
-import { isJsonSchemaObjectType, isStandardJsonSchema } from "@stryke/json";
-import { isSetString } from "@stryke/type-checks";
-import { isSetObject as isSetObject$1 } from "@stryke/type-checks/is-set-object";
+import { joinPaths } from "@stryke/path/join";
 import { extractJsonSchema as extractJsonSchema$1, isZod3Type } from "@stryke/zod";
 
 //#region src/extract.ts
+function convertNestedUntypedSchema(value) {
+	if (isUntypedSchema(value)) return convertUntypedSchemaToJsonSchema(value);
+	if (isSetObject$1(value)) {
+		if (isUntypedInput(value)) return convertUntypedInputToJsonSchema(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 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(value)) {
+			jsonSchema.$id = value;
+			continue;
+		}
+		if (key === "properties" || key === "patternProperties" || key === "dependentSchemas" || key === "$defs" || key === "definitions") {
+			if (!isSetObject$1(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 convertUntypedInputToJsonSchema(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$1(value)) continue;
+		if (isUntypedInput(value)) {
+			properties[key] = convertUntypedInputToJsonSchema(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);
+	}
+	const mergedProperties = {
+		...isSetObject$1(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. The function checks the type of the input and generates a hash based on its content. If the input is a Zod schema, it hashes the JSON representation of its internal definition. If the input is a Standard JSON Schema, it hashes the JSON representation of its internal standard schema. If the input is already a JSON Schema object, it hashes its JSON representation directly. If the input is a reflected Deepkit Type object, it hashes its JSON representation. The resulting hash string can be used for caching or comparison purposes.
+* Creates a hash string for a given schema definition input.
 */
 function extractHash(variant, input) {
 	if (isSetString(input)) return murmurhash({
@@ -30,10 +101,18 @@ function extractHash(variant, input) {
 			variant,
 			input: input["~standard"]
 		});
-		else if (isJsonSchemaObjectType(input)) return murmurhash({
+		else if (isJsonSchema(input)) return murmurhash({
 			variant,
 			input
 		});
+		else if (isUntypedInput(input)) return murmurhash({
+			variant,
+			input: convertUntypedInputToJsonSchema(input)
+		});
+		else if (isUntypedSchema(input)) return murmurhash({
+			variant,
+			input: convertUntypedSchemaToJsonSchema(input)
+		});
 		else if (isType(input)) return murmurhash({
 			variant,
 			input: stringifyType(input)
@@ -42,95 +121,47 @@ function extractHash(variant, input) {
 	throw new Error(`Failed to create an input hash for the provided schema definition input. The input must be a Zod schema, a Standard JSON Schema, a JSON Schema object, or a reflected Deepkit Type object.`);
 }
 /**
-* Converts a reflected Deepkit {@link @powerlines/deepkit/vendor/type#Type} into a JSON Schema (draft-07) representation.
-*
-* @remarks
-* This function delegates to an internal recursive walker that handles the full set of Deepkit reflection kinds.
-*
-* @param reflection - The reflected Deepkit Type to convert.
-* @returns A JSON Schema (draft-07) fragment representing the type, or `undefined` when no schema could be produced.
+* Converts a reflected Deepkit {@link Type} into a JSON Schema (draft-07) representation.
 */
 function extractReflection(reflection) {
 	if (!isType(reflection)) return;
 	return reflectionToJsonSchema(reflection);
 }
 /**
-* Extracts a JSON Type Definition (RFC 8927) schema from a given schema definition, if possible.
-*
-* @remarks
-* This function checks if the provided input is a Zod schema, a Standard JSON Schema, or already a JSON Schema object, extracts a JSON Schema fragment via the appropriate adapter (Zod and Standard Schema produce draft-07 fragments), and then converts that fragment into a valid JTD form suitable for AJV's JTD validator.
-*
-* @param schema - The schema definition to extract from. This can be a Zod schema, a Standard JSON Schema, or a JSON Schema object.
-* @returns The extracted JTD schema if successful, otherwise undefined.
+* Extracts a JSON Schema from Zod, Standard Schema, untyped, or JSON Schema inputs.
 */
 function extractJsonSchema(schema) {
-	if (isSetObject$1(schema) && (isZod3Type(schema) || isStandardJsonSchema(schema) || isJsonSchemaObjectType(schema) || isUntypedInput(schema) || isUntypedSchema(schema))) {
-		let jsonSchema;
-		if (isZod3Type(schema)) jsonSchema = extractJsonSchema$1(schema);
-		else if (isStandardJsonSchema(schema)) jsonSchema = schema["~standard"].jsonSchema.input({ target: "draft-2020-12" });
-		else if (isUntypedInput(schema)) jsonSchema = schema.$schema;
-		else jsonSchema = schema;
-		const jtd = jsonSchemaToJtd(jsonSchema);
-		if (jtd) return jtd;
+	if (isSetObject$1(schema) && (isZod3Type(schema) || isStandardJsonSchema(schema) || isJsonSchema(schema) || isUntypedInput(schema) || isUntypedSchema(schema))) {
+		if (isZod3Type(schema)) return extractJsonSchema$1(schema);
+		if (isStandardJsonSchema(schema)) return schema["~standard"].jsonSchema.input({ target: "draft-2020-12" });
+		if (isUntypedInput(schema)) return convertUntypedInputToJsonSchema(schema);
+		if (isUntypedSchema(schema)) return convertUntypedSchemaToJsonSchema(schema);
+		return schema;
 	}
 }
-/**
-* Extracts a schema definition from a given input object, which can be a Zod schema, a Standard JSON Schema, a JSON Schema object, or a reflected Deepkit Type object. The function checks the type of the input and attempts to extract the corresponding schema based on its variant. If the input is a Zod schema, it extracts the JSON Schema using the `extractJsonSchema` function. If the input is a Standard JSON Schema, it retrieves the JSON Schema targeting draft-07. If the input is already a JSON Schema object, it uses it directly. If the input is a reflected Deepkit Type object, it extracts the schema using the `extractReflection` function. The function returns a `Schema` containing the extracted schema and its variant if successful; otherwise, it throws an error.
-*
-* @param input - The input object to extract the schema definition from.
-* @returns A `Schema` containing the extracted schema and its variant if successful.
-* @throws An error if the input does not contain a valid schema definition.
-*/
 function extractResolvedVariant(input) {
 	if (isSetObject$1(input)) {
 		if (isZod3Type(input)) return "zod3";
 		else if (isStandardJsonSchema(input)) return "standard-schema";
-		else if (isJTDSchema(input)) return "jtd-schema";
-		else if (isJsonSchemaObjectType(input)) return "json-schema";
+		else if (isJsonSchema(input)) return "json-schema";
 		else if (isType(input)) return "reflection";
 		else if (isUntypedInput(input) || isUntypedSchema(input)) return "untyped";
 	}
 	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 reflected Deepkit Type object, or an Untyped schema.`);
 }
-/**
-* Extracts a schema definition from a given input object, which can be a Zod schema, a Standard JSON Schema, a JSON Schema object, a reflected Deepkit Type object, or an Untyped schema. The function checks the type of the input and attempts to extract the corresponding schema based on its variant. If the input is a Zod schema, it extracts the JSON Schema using the `extractJsonSchema` function. If the input is a Standard JSON Schema, it retrieves the JSON Schema targeting draft-07. If the input is already a JSON Schema object, it uses it directly. If the input is a reflected Deepkit Type object, it extracts the schema using the `extractReflection` function. The function returns a `Schema` containing the extracted schema and its variant if successful; otherwise, it throws an error.
-*
-* @param input - The input object to extract the schema definition from.
-* @returns A `Schema` containing the extracted schema and its variant if successful.
-* @throws An error if the input does not contain a valid schema definition.
-*/
 function extractVariant(input) {
 	if (isSetString(input) || isTypeDefinition(input)) return "type-definition";
 	return extractResolvedVariant(input);
 }
-/**
-* Extracts a JSON Schema object from a given schema definition input. The input can be a Zod schema, a Standard JSON Schema, a JSON Schema object, or a reflected Deepkit Type object. The function checks the type of the input and attempts to extract the corresponding JSON Schema based on its variant. If the input is a Zod schema, it extracts the JSON Schema using the `extractJsonSchema` function. If the input is a Standard JSON Schema, it retrieves the JSON Schema targeting draft-07. If the input is already a JSON Schema object, it uses it directly. If the input is a reflected Deepkit Type object, it extracts the schema using the `extractReflection` function. The function returns the extracted JSON Schema if successful; otherwise, it throws an error.
-*
-* @param input - The schema definition input to extract the JSON Schema from. This can be a Zod schema, a Standard JSON Schema, a JSON Schema object, or a TypeScript type definition.
-* @param variant - The variant of the schema definition to extract.
-* @returns The extracted JSON Schema if successful.
-* @throws An error if the input does not contain a valid schema definition.
-*/
 async function extractSchemaSchema(input, variant) {
 	if (isExtractedSchema(input)) return input.schema;
 	const resolvedVariant = variant ?? extractResolvedVariant(input);
 	let schema;
-	if (resolvedVariant === "zod3" || resolvedVariant === "json-schema" || resolvedVariant === "standard-schema" || resolvedVariant === "untyped") {
-		const jsonSchema = extractJsonSchema(input);
-		if (jsonSchema) schema = jsonSchemaToJtd(jsonSchema);
-	} else if (resolvedVariant === "reflection") schema = extractReflection(input);
-	else if (resolvedVariant === "jtd-schema") schema = input;
+	if (resolvedVariant === "zod3" || resolvedVariant === "json-schema" || resolvedVariant === "standard-schema" || resolvedVariant === "untyped") schema = extractJsonSchema(input);
+	else if (resolvedVariant === "reflection") schema = extractReflection(input);
 	if (schema) return 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 JTD schema, an untyped schema, or a reflected Deepkit Type object.`);
+	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, an untyped schema, or a reflected Deepkit Type object.`);
 }
-/**
-* Extracts a schema definition from a given input object, which can be a Zod schema, a Standard JSON Schema, a JSON Schema object, a JTD schema, an untyped schema, or a reflected Deepkit Type object. The function checks the type of the input and attempts to extract the corresponding schema based on its variant. If the input is a Zod schema, it extracts the JSON Schema using the `extractJsonSchema` function. If the input is a Standard JSON Schema, it retrieves the JSON Schema targeting draft-07. If the input is already a JSON Schema object, it uses it directly. If the input is a reflected Deepkit Type object, it extracts the schema using the `extractReflection` function. The function returns a `Schema` containing the extracted schema and its variant if successful; otherwise, it throws an error.
-*
-* @param variant - The variant of the schema definition to extract.
-* @param input - The input object to extract the schema definition from.
-* @returns A `Schema` containing the extracted schema and its variant if successful.
-* @throws An error if the input does not contain a valid schema definition.
-*/
 function extractSource(variant, input) {
 	if (variant === "zod3") return {
 		hash: extractHash(variant, input),
@@ -157,69 +188,70 @@ function extractSource(variant, input) {
 		variant: "reflection",
 		schema: input
 	};
-	else if (variant === "jtd-schema") return {
-		hash: extractHash(variant, input),
-		variant: "jtd-schema",
-		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, a JTD schema, an untyped schema, or a reflected Deepkit Type object.`);
+	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 the provided entry points to their corresponding type definitions. The function accepts an array of entry points, which can be strings (file paths) or type definition objects. It processes each entry point, resolving file paths and glob patterns to find matching files. For each resolved file, it creates a type definition object and resolves it using the `resolveInput` function. The function returns an array of resolved entry type definitions.
+* Extracts a JSON Schema from a given schema definition input, which can be a Zod schema, a Standard JSON Schema, a JSON Schema object, an untyped schema, or a reflected Deepkit Type object. If the input is a type definition reference (e.g. a file path with an export), it will be resolved and bundled using ESBuild to obtain the actual schema definition before extraction.
 *
 * @example
 * ```ts
 * // Resolve a schema definition from a file path
-* const schema1 = await extractSchema(context, "./schemas.ts#MySchema");
+* const schema1 = await extract(context, "./schemas.ts#MySchema");
 * // Resolve a schema definition from a JSON Schema object
-* const schema2 = await extractSchema(context, schemaObject);
+* const schema2 = await extract(context, schemaObject);
 * // Resolve a schema definition from a Zod schema
-* const schema3 = await extractSchema(context, zodSchema);
+* const schema3 = await extract(context, zodSchema);
 * // Resolve a schema definition from a reflected Deepkit Type object
-* const schema4 = await extractSchema(context, reflectionType);
+* const schema4 = await extract(context, reflectionType);
 * ```
 *
-* @param context - The plugin context used for resolving the schema definition input.
-* @param input - The schema definition input to extract the JSON Schema from. This can be a Zod schema, a Standard JSON Schema, a JSON Schema object, or a TypeScript type definition.
-* @param options - Optional overrides for the ESBuild configuration used during resolution.
-* @returns A promise that resolves to a {@link ExtractedSchema} containing the extracted JSON Schema and its variant, or the bytecode if JSON Schema extraction is not possible.
+* @see https://github.com/colinhacks/zod
+* @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://deepkit.io/en/documentation/runtime-types/reflection
+*
+* @param context - The context object providing access to the file system and cache path.
+* @param input - The schema definition input to extract, which can be a Zod schema, a Standard JSON Schema, a JSON Schema object, an untyped schema, or a reflected Deepkit Type object. If the input is a string or a type definition reference, it will be resolved and bundled to obtain the actual schema definition before extraction.
+* @param options - Optional overrides for the ESBuild configuration used during extraction. This can include custom plugins, loaders, or other build options to control how the schema definition is resolved and bundled when the input is a type definition reference.
+* @returns A promise that resolves to the extracted and normalized schema as a JSON Schema object. The function will attempt to extract a valid JSON Schema from the provided input, and if successful, it will return the schema. If the extraction process fails or if the input is not a valid schema definition, it will throw an error indicating the failure.
 */
 async function extractSchema(context, input, options = {}) {
 	if (isExtractedSchema(input)) return input;
 	if (isSchema(input)) return {
 		...input,
 		source: {
-			hash: extractHash("jtd-schema", input.schema),
-			variant: "jtd-schema",
+			hash: extractHash("json-schema", input.schema),
+			variant: "json-schema",
 			schema: input.schema
 		}
 	};
 	let source;
 	const variant = extractVariant(input);
+	const hash = extractHash(variant, input);
 	if (variant === "type-definition") {
-		const resolved = await resolve(context, input, defu(options, { plugins: [esbuildPlugin(context, {
+		const resolved = await resolve(context, input, defu(options, { plugins: [rolldownPlugin(context, {
 			reflection: "default",
 			level: "all"
 		})] }));
 		source = extractSource(extractResolvedVariant(resolved), resolved);
 	} else if ([
 		"json-schema",
-		"jtd-schema",
 		"standard-schema",
 		"zod3",
 		"untyped",
 		"reflection"
 	].includes(variant)) source = extractSource(variant, input);
-	else throw new Error(`Invalid schema definition input "${variant}". The variant must be one of "type-definition", "json-schema", "jtd-schema", "standard-schema", "zod3", "untyped", or "reflection".`);
+	else throw new Error(`Invalid schema definition input "${variant}". The variant must be one of "type-definition", "json-schema", "standard-schema", "zod3", "untyped", or "reflection".`);
 	return {
 		variant,
 		source,
 		schema: await extractSchemaSchema(source.schema, source.variant),
-		hash: extractHash(variant, input)
+		hash
 	};
 }
 /**
-* Resolves the provided entry points to their corresponding type definitions. The function accepts an array of entry points, which can be strings (file paths) or type definition objects. It processes each entry point, resolving file paths and glob patterns to find matching files. For each resolved file, it creates a type definition object and resolves it using the `resolveInput` function. The function returns an array of resolved entry type definitions.
+* Extracts a JSON Schema from a given schema definition input, which can be a Zod schema, a Standard JSON Schema, a JSON Schema object, an untyped schema, or a reflected Deepkit Type object. If the input is a type definition reference (e.g. a file path with an export), it will be resolved and bundled using ESBuild to obtain the actual schema definition before extraction.
 *
 * @example
 * ```ts
@@ -241,13 +273,30 @@ async function extractSchema(context, input, options = {}) {
 * @see https://github.com/unjs/untyped
 * @see https://www.typescriptlang.org/docs/handbook/2/types-from-types.html
 *
-* @param context - The {@link Context | context} used for resolving the {@link Schema | schema} definition input.
-* @param input - The input object or string to extract the {@link Schema | schema} from. This can be {@link TypeDefinitionReference | a string that references a Typescript module}, a [Zod v3 schema](https://github.com/colinhacks/zod), any type that adheres to [the Standard JSON Schema specification](https://standardschema.dev/json-schema#what-schema-libraries-support-this-spec), a [JSON Schema object](https://json-schema.org/), a [JTD schema object](https://ajv.js.org/json-type-definition.html), an [untyped schema](https://github.com/unjs/untyped), or a [TypeScript type reflection](https://deepkit.io/en/documentation/runtime-types/reflection).
-* @param options - Optional overrides for the [ESBuild configuration](https://esbuild.github.io/api/#general-options) used during resolution.
-* @returns A promise that resolves to a {@link Schema | schema} object parsed from the input.
+* @param context - The context object providing access to the file system and cache path.
+* @param input - The schema definition input to extract, which can be a Zod schema, a Standard JSON Schema, a JSON Schema object, an untyped schema, or a reflected Deepkit Type object.
+* @param options - Optional overrides for the ESBuild 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(context, input, options = {}) {
-	return await extractSchema(context, input, options);
+	if (isExtractedSchema(input) || isSchema(input)) return input;
+	let result;
+	const variant = extractVariant(input);
+	const hash = extractHash(variant, input);
+	const cacheFilePath = joinPaths(getCacheDirectory(context), `${hash}.json`);
+	if (context.config.skipCache !== true && context.fs.existsSync(cacheFilePath)) {
+		const schema = await context.fs.read(cacheFilePath);
+		if (schema) result = {
+			variant,
+			hash,
+			schema: JSON.parse(schema)
+		};
+	}
+	result ??= await extractSchema(context, 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 Standard JSON Schema, a JSON Schema object, an untyped schema, or a reflected Deepkit Type object.`);
+	if (context.config.skipCache !== true) await writeSchema(context, result);
+	return result;
 }
 
 //#endregion