@powerlines/schema 0.11.1 → 0.11.2

package/dist/extract.d.cts

@@ -1,10 +1,13 @@
-import { SchemaDefinition, SchemaDefinitionInput, SchemaDefinitionParameter } from "./types.cjs";
-import { PluginContext } from "@powerlines/core";
+import { ExtractedSchema, JTDSchemaType, Schema, SchemaInput, SchemaInputVariant, SchemaMetadata, SchemaSource, SchemaSourceInput, SchemaSourceVariant } from "./types.cjs";
+import { Context } from "@powerlines/core";
 import { BuildOptions } from "esbuild";
 import { Type } from "@powerlines/deepkit/vendor/type";
-import { JsonSchema7Type } from "@stryke/json";
 
 //#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.
+ */
+declare function extractHash(variant: SchemaInputVariant, input: SchemaInput): string;
 /**
  * Converts a reflected Deepkit {@link @powerlines/deepkit/vendor/type#Type} into a JSON Schema (draft-07) representation.
  *
@@ -14,39 +17,101 @@ import { JsonSchema7Type } from "@stryke/json";
  * @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.
  */
-declare function extractReflection(reflection: Type): JsonSchema7Type | undefined;
+declare function extractReflection<TMetadata extends Partial<SchemaMetadata> = Partial<SchemaMetadata>>(reflection: Type): JTDSchemaType<TMetadata> | undefined;
 /**
- * Extracts a JSON Schema object from a given schema definition, if possible.
+ * Extracts a JSON Type Definition (RFC 8927) schema from a given schema definition, if possible.
  *
  * @remarks
- * This function checks if the provided schema is a Zod schema, a Standard JSON Schema, or already a JSON Schema object. If it is a Zod schema, it extracts the corresponding JSON Schema. If it is a Standard JSON Schema, it retrieves the input JSON Schema targeting draft-07. Finally, it checks if the resulting JSON Schema is an object type and returns it if so.
+ * 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.
+ */
+declare function extractResolvedVariant(input: SchemaSourceInput): SchemaSourceVariant;
+/**
+ * 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 schema - The schema definition to extract the JSON Schema from. This can be a Zod schema, a Standard JSON Schema, or a JSON Schema object.
- * @returns The extracted JSON Schema (draft-07) object if successful, otherwise undefined.
+ * @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 extractJsonSchema(schema: unknown): JsonSchema7Type | undefined;
+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, 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 `SchemaDefinition` containing the extracted schema and its variant if successful; otherwise, it throws an error.
+ * 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 `SchemaDefinition` containing the extracted schema and its variant if successful.
+ * @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 extractSchema(input: SchemaDefinitionInput): SchemaDefinition;
+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.
  *
  * @example
  * ```ts
- * const schema = await extract(context, "./schemas/*.ts");
+ * // Resolve a schema definition from a file path
+ * const schema1 = await extractSchema(context, "./schemas.ts#MySchema");
+ * // Resolve a schema definition from a JSON Schema object
+ * const schema2 = await extractSchema(context, schemaObject);
+ * // Resolve a schema definition from a Zod schema
+ * const schema3 = await extractSchema(context, zodSchema);
+ * // Resolve a schema definition from a reflected Deepkit Type object
+ * const schema4 = await extractSchema(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 SchemaDefinition containing the extracted JSON Schema and its variant, or the bytecode if JSON Schema extraction is not possible.
+ * @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.
+ */
+declare function extractSchema<TMetadata extends Partial<SchemaMetadata> = Partial<SchemaMetadata>, TContext extends Context = Context>(context: TContext, input: SchemaInput, options?: Partial<BuildOptions>): Promise<ExtractedSchema<TMetadata>>;
+/**
+ * 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.
+ *
+ * @example
+ * ```ts
+ * // Resolve a schema definition from a file path
+ * const schema1 = await extract(context, "./schemas.ts#MySchema");
+ * // Resolve a schema definition from a JSON Schema object
+ * const schema2 = await extract(context, schemaObject);
+ * // Resolve a schema definition from a Zod schema
+ * const schema3 = await extract(context, zodSchema);
+ * // Resolve a schema definition from a reflected Deepkit Type object
+ * const schema4 = await extract(context, reflectionType);
+ * ```
+ *
+ * @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
+ * @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.
  */
-declare function extract<TContext extends PluginContext = PluginContext>(context: TContext, input: SchemaDefinitionParameter, options?: Partial<BuildOptions>): Promise<SchemaDefinition>;
+declare function extract<TMetadata extends Partial<SchemaMetadata> = Partial<SchemaMetadata>, TContext extends Context = Context>(context: TContext, input: SchemaInput, options?: Partial<BuildOptions>): Promise<Schema<TMetadata>>;
 //#endregion
-export { extract, extractJsonSchema, extractReflection, extractSchema };
+export { extract, extractHash, extractJsonSchema, extractReflection, extractResolvedVariant, extractSchema, extractSchemaSchema, extractSource, extractVariant };
 //# sourceMappingURL=extract.d.cts.map

package/dist/extract.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"extract.d.cts","names":[],"sources":["../src/extract.ts"],"mappings":";;;;;;;;;AA+CA;;;;;;;iBAAgB,iBAAA,CACd,UAAA,EAAY,IAAA,GACX,eAAA;;AAiBH;;;;;AAmCA;;;iBAnCgB,iBAAA,CACd,MAAA,YACC,eAAA;;;;;;AA4FH;;iBA3DgB,aAAA,CAAc,KAAA,EAAO,qBAAA,GAAwB,gBAAA;;;;;;;;;;;;;;iBA2DvC,OAAA,kBAAyB,aAAA,GAAgB,aAAA,CAAA,CAC7D,OAAA,EAAS,QAAA,EACT,KAAA,EAAO,yBAAA,EACP,OAAA,GAAS,OAAA,CAAQ,YAAA,IAChB,OAAA,CAAQ,gBAAA"}
+{"version":3,"file":"extract.d.cts","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"}

package/dist/extract.d.mts

@@ -1,10 +1,13 @@
-import { SchemaDefinition, SchemaDefinitionInput, SchemaDefinitionParameter } from "./types.mjs";
+import { ExtractedSchema, JTDSchemaType, Schema, SchemaInput, SchemaInputVariant, SchemaMetadata, SchemaSource, SchemaSourceInput, SchemaSourceVariant } from "./types.mjs";
 import { BuildOptions } from "esbuild";
-import { PluginContext } from "@powerlines/core";
+import { Context } from "@powerlines/core";
 import { Type } from "@powerlines/deepkit/vendor/type";
-import { JsonSchema7Type } from "@stryke/json";
 
 //#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.
+ */
+declare function extractHash(variant: SchemaInputVariant, input: SchemaInput): string;
 /**
  * Converts a reflected Deepkit {@link @powerlines/deepkit/vendor/type#Type} into a JSON Schema (draft-07) representation.
  *
@@ -14,39 +17,101 @@ import { JsonSchema7Type } from "@stryke/json";
  * @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.
  */
-declare function extractReflection(reflection: Type): JsonSchema7Type | undefined;
+declare function extractReflection<TMetadata extends Partial<SchemaMetadata> = Partial<SchemaMetadata>>(reflection: Type): JTDSchemaType<TMetadata> | undefined;
 /**
- * Extracts a JSON Schema object from a given schema definition, if possible.
+ * Extracts a JSON Type Definition (RFC 8927) schema from a given schema definition, if possible.
  *
  * @remarks
- * This function checks if the provided schema is a Zod schema, a Standard JSON Schema, or already a JSON Schema object. If it is a Zod schema, it extracts the corresponding JSON Schema. If it is a Standard JSON Schema, it retrieves the input JSON Schema targeting draft-07. Finally, it checks if the resulting JSON Schema is an object type and returns it if so.
+ * 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.
+ */
+declare function extractResolvedVariant(input: SchemaSourceInput): SchemaSourceVariant;
+/**
+ * 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 schema - The schema definition to extract the JSON Schema from. This can be a Zod schema, a Standard JSON Schema, or a JSON Schema object.
- * @returns The extracted JSON Schema (draft-07) object if successful, otherwise undefined.
+ * @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 extractJsonSchema(schema: unknown): JsonSchema7Type | undefined;
+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, 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 `SchemaDefinition` containing the extracted schema and its variant if successful; otherwise, it throws an error.
+ * 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 `SchemaDefinition` containing the extracted schema and its variant if successful.
+ * @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 extractSchema(input: SchemaDefinitionInput): SchemaDefinition;
+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.
  *
  * @example
  * ```ts
- * const schema = await extract(context, "./schemas/*.ts");
+ * // Resolve a schema definition from a file path
+ * const schema1 = await extractSchema(context, "./schemas.ts#MySchema");
+ * // Resolve a schema definition from a JSON Schema object
+ * const schema2 = await extractSchema(context, schemaObject);
+ * // Resolve a schema definition from a Zod schema
+ * const schema3 = await extractSchema(context, zodSchema);
+ * // Resolve a schema definition from a reflected Deepkit Type object
+ * const schema4 = await extractSchema(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 SchemaDefinition containing the extracted JSON Schema and its variant, or the bytecode if JSON Schema extraction is not possible.
+ * @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.
+ */
+declare function extractSchema<TMetadata extends Partial<SchemaMetadata> = Partial<SchemaMetadata>, TContext extends Context = Context>(context: TContext, input: SchemaInput, options?: Partial<BuildOptions>): Promise<ExtractedSchema<TMetadata>>;
+/**
+ * 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.
+ *
+ * @example
+ * ```ts
+ * // Resolve a schema definition from a file path
+ * const schema1 = await extract(context, "./schemas.ts#MySchema");
+ * // Resolve a schema definition from a JSON Schema object
+ * const schema2 = await extract(context, schemaObject);
+ * // Resolve a schema definition from a Zod schema
+ * const schema3 = await extract(context, zodSchema);
+ * // Resolve a schema definition from a reflected Deepkit Type object
+ * const schema4 = await extract(context, reflectionType);
+ * ```
+ *
+ * @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
+ * @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.
  */
-declare function extract<TContext extends PluginContext = PluginContext>(context: TContext, input: SchemaDefinitionParameter, options?: Partial<BuildOptions>): Promise<SchemaDefinition>;
+declare function extract<TMetadata extends Partial<SchemaMetadata> = Partial<SchemaMetadata>, TContext extends Context = Context>(context: TContext, input: SchemaInput, options?: Partial<BuildOptions>): Promise<Schema<TMetadata>>;
 //#endregion
-export { extract, extractJsonSchema, extractReflection, extractSchema };
+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":";;;;;;;;;AA+CA;;;;;;;iBAAgB,iBAAA,CACd,UAAA,EAAY,IAAA,GACX,eAAA;;AAiBH;;;;;AAmCA;;;iBAnCgB,iBAAA,CACd,MAAA,YACC,eAAA;;;;;;AA4FH;;iBA3DgB,aAAA,CAAc,KAAA,EAAO,qBAAA,GAAwB,gBAAA;;;;;;;;;;;;;;iBA2DvC,OAAA,kBAAyB,aAAA,GAAgB,aAAA,CAAA,CAC7D,OAAA,EAAS,QAAA,EACT,KAAA,EAAO,yBAAA,EACP,OAAA,GAAS,OAAA,CAAQ,YAAA,IAChB,OAAA,CAAQ,gBAAA"}
+{"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"}

package/dist/extract.mjs

@@ -1,17 +1,47 @@
-import { isSchemaDefinition } from "./is-schema-definition.mjs";
+import { jsonSchemaToJtd } from "./jtd.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 { isTypeDefinition } from "@powerlines/core";
 import { esbuildPlugin } from "@powerlines/deepkit/esbuild-plugin";
-import { isType } from "@powerlines/deepkit/vendor/type";
-import { isJsonSchema7ObjectType, isStandardJsonSchema } from "@stryke/json";
+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 { extractJsonSchema7, isZod3Type } from "@stryke/zod";
+import { extractJsonSchema as extractJsonSchema$1, isZod3Type } from "@stryke/zod";
 
 //#region src/extract.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.
+*/
+function extractHash(variant, input) {
+	if (isSetString(input)) return murmurhash({
+		variant,
+		input
+	});
+	else if (isSetObject$1(input)) {
+		if (isZod3Type(input)) return murmurhash({
+			variant,
+			input: input._def
+		});
+		else if (isStandardJsonSchema(input)) return murmurhash({
+			variant,
+			input: input["~standard"]
+		});
+		else if (isJsonSchemaObjectType(input)) return murmurhash({
+			variant,
+			input
+		});
+		else if (isType(input)) return murmurhash({
+			variant,
+			input: stringifyType(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
@@ -25,87 +55,201 @@ function extractReflection(reflection) {
 	return reflectionToJsonSchema(reflection);
 }
 /**
-* Extracts a JSON Schema object from a given schema definition, if possible.
+* Extracts a JSON Type Definition (RFC 8927) schema from a given schema definition, if possible.
 *
 * @remarks
-* This function checks if the provided schema is a Zod schema, a Standard JSON Schema, or already a JSON Schema object. If it is a Zod schema, it extracts the corresponding JSON Schema. If it is a Standard JSON Schema, it retrieves the input JSON Schema targeting draft-07. Finally, it checks if the resulting JSON Schema is an object type and returns it if so.
+* 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 the JSON Schema from. This can be a Zod schema, a Standard JSON Schema, or a JSON Schema object.
-* @returns The extracted JSON Schema (draft-07) object if successful, otherwise undefined.
+* @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.
 */
 function extractJsonSchema(schema) {
-	if (isSetObject$1(schema) && (isZod3Type(schema) || isStandardJsonSchema(schema) || isJsonSchema7ObjectType(schema))) {
+	if (isSetObject$1(schema) && (isZod3Type(schema) || isStandardJsonSchema(schema) || isJsonSchemaObjectType(schema) || isUntypedInput(schema) || isUntypedSchema(schema))) {
 		let jsonSchema;
-		if (isZod3Type(schema)) jsonSchema = extractJsonSchema7(schema);
-		else if (isStandardJsonSchema(schema)) jsonSchema = schema["~standard"].jsonSchema.input({ target: "draft-07" });
+		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;
-		if (isJsonSchema7ObjectType(jsonSchema)) return jsonSchema;
+		const jtd = jsonSchemaToJtd(jsonSchema);
+		if (jtd) return jtd;
 	}
 }
 /**
-* 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 `SchemaDefinition` containing the extracted schema and its variant if successful; otherwise, it throws an error.
+* 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 `SchemaDefinition` containing the extracted schema and its variant if successful.
+* @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 extractSchema(input) {
+function extractResolvedVariant(input) {
 	if (isSetObject$1(input)) {
-		if (isZod3Type(input)) {
-			const schema = extractJsonSchema(input);
-			if (schema) return {
-				schema,
-				variant: "zod3",
-				input
-			};
-		} else if (isStandardJsonSchema(input)) {
-			const schema = extractJsonSchema(input);
-			if (schema) return {
-				schema,
-				variant: "standard-schema",
-				input
-			};
-		} else if (isJsonSchema7ObjectType(input)) {
-			const schema = extractJsonSchema(input);
-			if (schema) return {
-				schema,
-				variant: "json-schema",
-				input
-			};
-		} else if (isType(input)) {
-			const schema = extractReflection(input);
-			if (schema) return {
-				schema,
-				variant: "reflection",
-				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 (isType(input)) return "reflection";
+		else if (isUntypedInput(input) || isUntypedSchema(input)) return "untyped";
 	}
-	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, or a reflected Deepkit Type object.`);
+	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 (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.`);
+}
+/**
+* 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),
+		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 === "reflection") return {
+		hash: extractHash(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.`);
 }
 /**
 * 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.
 *
 * @example
 * ```ts
-* const schema = await extract(context, "./schemas/*.ts");
+* // Resolve a schema definition from a file path
+* const schema1 = await extractSchema(context, "./schemas.ts#MySchema");
+* // Resolve a schema definition from a JSON Schema object
+* const schema2 = await extractSchema(context, schemaObject);
+* // Resolve a schema definition from a Zod schema
+* const schema3 = await extractSchema(context, zodSchema);
+* // Resolve a schema definition from a reflected Deepkit Type object
+* const schema4 = await extractSchema(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 SchemaDefinition containing the extracted JSON Schema and its variant, or the bytecode if JSON Schema extraction is not possible.
+* @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.
+*/
+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",
+			schema: input.schema
+		}
+	};
+	let source;
+	const variant = extractVariant(input);
+	if (variant === "type-definition") {
+		const resolved = await resolve(context, input, defu(options, { plugins: [esbuildPlugin(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".`);
+	return {
+		variant,
+		source,
+		schema: await extractSchemaSchema(source.schema, source.variant),
+		hash: extractHash(variant, input)
+	};
+}
+/**
+* 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.
+*
+* @example
+* ```ts
+* // Resolve a schema definition from a file path
+* const schema1 = await extract(context, "./schemas.ts#MySchema");
+* // Resolve a schema definition from a JSON Schema object
+* const schema2 = await extract(context, schemaObject);
+* // Resolve a schema definition from a Zod schema
+* const schema3 = await extract(context, zodSchema);
+* // Resolve a schema definition from a reflected Deepkit Type object
+* const schema4 = await extract(context, reflectionType);
+* ```
+*
+* @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
+* @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.
 */
 async function extract(context, input, options = {}) {
-	if (isSchemaDefinition(input)) return input;
-	let inputObject = input;
-	if (isSetString(input) || isTypeDefinition(input)) inputObject = await resolve(context, input, defu(options, { plugins: [esbuildPlugin(context, {
-		reflection: "default",
-		level: "all"
-	})] }));
-	return extractSchema(inputObject);
+	return await extractSchema(context, input, options);
 }
 
 //#endregion
-export { extract, extractJsonSchema, extractReflection, extractSchema };
+export { extract, extractHash, extractJsonSchema, extractReflection, extractResolvedVariant, extractSchema, extractSchemaSchema, extractSource, extractVariant };
 //# sourceMappingURL=extract.mjs.map