@powerlines/schema 0.11.1 → 0.11.2

package/README.md

@@ -32,7 +32,7 @@ This package is part of the <b>🔌 Powerlines</b> monorepo. Powerlines is the "
 <!-- prettier-ignore-start -->
 <!-- markdownlint-disable -->
 
-> [!IMPORTANT] 
+> [!IMPORTANT]
 > This repository, and the apps, libraries, and tools contained within, is still in it's initial development phase. As a result, bugs and issues are expected with it's usage. When the main development phase completes, a proper release will be performed, the packages will be available through NPM (and other distributions), and this message will be removed. However, in the meantime, please feel free to report any issues you may come across.
 
 <!-- markdownlint-restore -->
@@ -49,28 +49,42 @@ This package is part of the <b>🔌 Powerlines</b> monorepo. Powerlines is the "
 
 <!-- END header -->
 
-# Powerlines - Deepkit Transform Plugin
+# Powerlines - Schema Package
 
-A package containing the Deepkit plugin for Powerlines, various helper utilities, and shared configurations.
+A package for extracting and resolving schemas from various input formats, including Zod schemas, JSON Schemas, JTD schemas, untyped schemas, and TypeScript type reflections. This package provides a unified interface for working with different schema formats and extracting relevant information for use in other parts of the Powerlines framework.
+
+The input can be one of the following formats:
+
+- A string that references a Typescript module's export (can be in the format `module#export` or just `module`, in which case it will attempt to resolve the default export)
+- 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)
+- A [TypeScript type reflection](https://deepkit.io/en/documentation/runtime-types/reflection)
+
+By allowing for multiple input formats, this package provides flexibility and ease of use for developers working with different schema definitions. It abstracts away the complexities of handling various schema formats and provides a consistent interface for extracting and working with schemas across the Powerlines framework.
 
 <!-- START doctoc -->
 <!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
 
 ## Table of Contents
 
-- [Installing](#installing)
-- [Reduced Package Size](#reduced-package-size)
-- [Development](#development)
-  - [Building](#building)
-  - [Running unit tests](#running-unit-tests)
-  - [Linting](#linting)
-- [Storm Workspaces](#storm-workspaces)
-- [Roadmap](#roadmap)
-- [Support](#support)
-- [License](#license)
-- [Changelog](#changelog)
-- [Contributing](#contributing)
-- [Contributors](#contributors)
+- [Powerlines - Schema Package](#powerlines---schema-package)
+  - [Table of Contents](#table-of-contents)
+  - [Installing](#installing)
+  - [Reduced Package Size](#reduced-package-size)
+  - [Development](#development)
+    - [Building](#building)
+    - [Running unit tests](#running-unit-tests)
+    - [Linting](#linting)
+  - [Storm Workspaces](#storm-workspaces)
+  - [Roadmap](#roadmap)
+  - [Support](#support)
+  - [License](#license)
+  - [Changelog](#changelog)
+  - [Contributing](#contributing)
+  - [Contributors](#contributors)
 
 <!-- END doctoc -->
 
@@ -79,14 +93,14 @@ A package containing the Deepkit plugin for Powerlines, various helper utilities
 Using [pnpm](http://pnpm.io):
 
 ```bash
-pnpm add @powerlines/plugin-deepkit
+pnpm add @powerlines/schema
 ```
 
 <details>
   <summary>Using npm</summary>
 
 ```bash
-npm install @powerlines/plugin-deepkit
+npm install @powerlines/schema
 ```
 
 </details>
@@ -95,7 +109,7 @@ npm install @powerlines/plugin-deepkit
   <summary>Using yarn</summary>
 
 ```bash
-yarn add @powerlines/plugin-deepkit
+yarn add @powerlines/schema
 ```
 
 </details>
@@ -114,16 +128,16 @@ commands are available to assist in development.
 
 ### Building
 
-Run `nx build plugin-deepkit` to build the library.
+Run `nx build schema` to build the library.
 
 ### Running unit tests
 
-Run `nx test plugin-deepkit` to execute the unit tests via
+Run `nx test schema` to execute the unit tests via
 [Jest](https://jestjs.io).
 
 ### Linting
 
-Run `nx lint plugin-deepkit` to run
+Run `nx lint schema` to run
 [ESLint](https://eslint.org/) on the package.
 
 <!-- START footer -->

package/dist/bundle.d.cts

@@ -1,4 +1,4 @@
-import { PluginContext, ResolveOptions } from "@powerlines/core";
+import { ResolveOptions, UnresolvedContext } from "@powerlines/core";
 import { DeepPartial } from "@stryke/types/base";
 import { BuildOptions, OutputFile } from "esbuild";
 
@@ -15,7 +15,7 @@ type BundleOptions = DeepPartial<BuildOptions> & {
  * @param options - Optional overrides for the ESBuild configuration.
  * @returns A promise that resolves to the bundled module.
  */
-declare function bundle<TContext extends PluginContext = PluginContext>(context: TContext, file: string, options?: BundleOptions): Promise<OutputFile>;
+declare function bundle<TContext extends UnresolvedContext>(context: TContext, file: string, options?: BundleOptions): Promise<OutputFile>;
 //#endregion
 export { BundleOptions, bundle };
 //# sourceMappingURL=bundle.d.cts.map

package/dist/bundle.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"bundle.d.cts","names":[],"sources":["../src/bundle.ts"],"mappings":";;;;;KAiCY,aAAA,GAAgB,WAAA,CAAY,YAAA;EACtC,IAAA;EACA,OAAA,GAAU,WAAA,CAAY,cAAA;AAAA;;;;;;;;;iBAWF,MAAA,kBAAwB,aAAA,GAAgB,aAAA,CAAA,CAC5D,OAAA,EAAS,QAAA,EACT,IAAA,UACA,OAAA,GAAS,aAAA,GACR,OAAA,CAAQ,UAAA"}
+{"version":3,"file":"bundle.d.cts","names":[],"sources":["../src/bundle.ts"],"mappings":";;;;;KAiCY,aAAA,GAAgB,WAAA,CAAY,YAAA;EACtC,IAAA;EACA,OAAA,GAAU,WAAA,CAAY,cAAA;AAAA;;;;;;;;;iBAWF,MAAA,kBAAwB,iBAAA,CAAA,CAC5C,OAAA,EAAS,QAAA,EACT,IAAA,UACA,OAAA,GAAS,aAAA,GACR,OAAA,CAAQ,UAAA"}

package/dist/bundle.d.mts

@@ -1,5 +1,5 @@
 import { BuildOptions, OutputFile } from "esbuild";
-import { PluginContext, ResolveOptions } from "@powerlines/core";
+import { ResolveOptions, UnresolvedContext } from "@powerlines/core";
 import { DeepPartial } from "@stryke/types/base";
 
 //#region src/bundle.d.ts
@@ -15,7 +15,7 @@ type BundleOptions = DeepPartial<BuildOptions> & {
  * @param options - Optional overrides for the ESBuild configuration.
  * @returns A promise that resolves to the bundled module.
  */
-declare function bundle<TContext extends PluginContext = PluginContext>(context: TContext, file: string, options?: BundleOptions): Promise<OutputFile>;
+declare function bundle<TContext extends UnresolvedContext>(context: TContext, file: string, options?: BundleOptions): Promise<OutputFile>;
 //#endregion
 export { BundleOptions, bundle };
 //# sourceMappingURL=bundle.d.mts.map

package/dist/bundle.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"bundle.d.mts","names":[],"sources":["../src/bundle.ts"],"mappings":";;;;;KAiCY,aAAA,GAAgB,WAAA,CAAY,YAAA;EACtC,IAAA;EACA,OAAA,GAAU,WAAA,CAAY,cAAA;AAAA;;;;;;;;;iBAWF,MAAA,kBAAwB,aAAA,GAAgB,aAAA,CAAA,CAC5D,OAAA,EAAS,QAAA,EACT,IAAA,UACA,OAAA,GAAS,aAAA,GACR,OAAA,CAAQ,UAAA"}
+{"version":3,"file":"bundle.d.mts","names":[],"sources":["../src/bundle.ts"],"mappings":";;;;;KAiCY,aAAA,GAAgB,WAAA,CAAY,YAAA;EACtC,IAAA;EACA,OAAA,GAAU,WAAA,CAAY,cAAA;AAAA;;;;;;;;;iBAWF,MAAA,kBAAwB,iBAAA,CAAA,CAC5C,OAAA,EAAS,QAAA,EACT,IAAA,UACA,OAAA,GAAS,aAAA,GACR,OAAA,CAAQ,UAAA"}

package/dist/bundle.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"bundle.mjs","names":[],"sources":["../src/bundle.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                   ⚡ Storm Software - Powerlines\n\n This code was released as part of the Powerlines project. Powerlines\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/powerlines.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/powerlines\n Documentation:            https://docs.stormsoftware.com/projects/powerlines\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nimport type {\n  CreateUnpluginResolverOptions,\n  PluginContext,\n  ResolveOptions\n} from \"@powerlines/core\";\nimport { createUnpluginResolver } from \"@powerlines/core/lib/unplugin\";\nimport { resolveOptions } from \"@powerlines/unplugin/esbuild\";\nimport { omit } from \"@stryke/helpers/omit\";\nimport { findFileName } from \"@stryke/path/file-path-fns\";\nimport { DeepPartial } from \"@stryke/types/base\";\nimport defu from \"defu\";\nimport type { BuildOptions } from \"esbuild\";\nimport { build, OutputFile } from \"esbuild\";\nimport { createEsbuildPlugin } from \"unplugin\";\n\nexport type BundleOptions = DeepPartial<BuildOptions> & {\n  name?: string;\n  resolve?: DeepPartial<ResolveOptions>;\n};\n\n/**\n * Bundle a type definition to a module.\n *\n * @param context - The context object containing the environment paths.\n * @param file - The file path to bundle.\n * @param options - Optional overrides for the ESBuild configuration.\n * @returns A promise that resolves to the bundled module.\n */\nexport async function bundle<TContext extends PluginContext = PluginContext>(\n  context: TContext,\n  file: string,\n  options: BundleOptions = {}\n): Promise<OutputFile> {\n  const path = await context.fs.resolve(file);\n  if (!path || !context.fs.existsSync(path)) {\n    throw new Error(\n      `Module not found: \"${file}\". Please check the path and try again.`\n    );\n  }\n\n  const result = await build(\n    defu(\n      {\n        entryPoints: [path],\n        write: false,\n        sourcemap: false,\n        splitting: false,\n        treeShaking: true,\n        bundle: true,\n        packages: \"bundle\",\n        platform: \"node\",\n        logLevel: \"silent\",\n        ...omit(options, [\"name\", \"resolve\"])\n      },\n      resolveOptions(context),\n      {\n        plugins: [\n          createEsbuildPlugin(\n            createUnpluginResolver(context, {\n              name: options.name ?? `${findFileName(file)} Bundler`,\n              prefix: false,\n              overrides: defu(\n                options.resolve ?? {},\n                { skipNodeModulesBundle: false },\n                context.config.resolve\n              ) as CreateUnpluginResolverOptions[\"overrides\"],\n              silenceHookLogging: true\n            })\n          )()\n        ]\n      }\n    )\n  );\n  if (result.errors.length > 0) {\n    throw new Error(\n      `Failed to bundle ${file}: ${result.errors\n        .map(error => error.text)\n        .join(\", \")}`\n    );\n  }\n  if (result.warnings.length > 0) {\n    context.warn(\n      `Warnings while bundling ${file}: ${result.warnings\n        .map(warning => warning.text)\n        .join(\", \")}`\n    );\n  }\n  if (!result.outputFiles || result.outputFiles.filter(Boolean).length === 0) {\n    throw new Error(\n      `No output files generated for ${\n        file\n      }. Please check the configuration and try again.`\n    );\n  }\n\n  return result.outputFiles.filter(Boolean)[0]!;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AA8CA,eAAsB,OACpB,SACA,MACA,UAAyB,EAAE,EACN;CACrB,MAAM,OAAO,MAAM,QAAQ,GAAG,QAAQ,KAAK;AAC3C,KAAI,CAAC,QAAQ,CAAC,QAAQ,GAAG,WAAW,KAAK,CACvC,OAAM,IAAI,MACR,sBAAsB,KAAK,yCAC5B;CAGH,MAAM,SAAS,MAAM,MACnB,KACE;EACE,aAAa,CAAC,KAAK;EACnB,OAAO;EACP,WAAW;EACX,WAAW;EACX,aAAa;EACb,QAAQ;EACR,UAAU;EACV,UAAU;EACV,UAAU;EACV,GAAG,KAAK,SAAS,CAAC,QAAQ,UAAU,CAAC;EACtC,EACD,eAAe,QAAQ,EACvB,EACE,SAAS,CACP,oBACE,uBAAuB,SAAS;EAC9B,MAAM,QAAQ,QAAQ,GAAG,aAAa,KAAK,CAAC;EAC5C,QAAQ;EACR,WAAW,KACT,QAAQ,WAAW,EAAE,EACrB,EAAE,uBAAuB,OAAO,EAChC,QAAQ,OAAO,QAChB;EACD,oBAAoB;EACrB,CAAC,CACH,EAAE,CACJ,EACF,CACF,CACF;AACD,KAAI,OAAO,OAAO,SAAS,EACzB,OAAM,IAAI,MACR,oBAAoB,KAAK,IAAI,OAAO,OACjC,KAAI,UAAS,MAAM,KAAK,CACxB,KAAK,KAAK,GACd;AAEH,KAAI,OAAO,SAAS,SAAS,EAC3B,SAAQ,KACN,2BAA2B,KAAK,IAAI,OAAO,SACxC,KAAI,YAAW,QAAQ,KAAK,CAC5B,KAAK,KAAK,GACd;AAEH,KAAI,CAAC,OAAO,eAAe,OAAO,YAAY,OAAO,QAAQ,CAAC,WAAW,EACvE,OAAM,IAAI,MACR,iCACE,KACD,iDACF;AAGH,QAAO,OAAO,YAAY,OAAO,QAAQ,CAAC"}
+{"version":3,"file":"bundle.mjs","names":[],"sources":["../src/bundle.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                   ⚡ Storm Software - Powerlines\n\n This code was released as part of the Powerlines project. Powerlines\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/powerlines.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/powerlines\n Documentation:            https://docs.stormsoftware.com/projects/powerlines\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nimport type {\n  CreateUnpluginResolverOptions,\n  ResolveOptions,\n  UnresolvedContext\n} from \"@powerlines/core\";\nimport { createUnpluginResolver } from \"@powerlines/core/lib/unplugin\";\nimport { resolveOptions } from \"@powerlines/unplugin/esbuild\";\nimport { omit } from \"@stryke/helpers/omit\";\nimport { findFileName } from \"@stryke/path/file-path-fns\";\nimport { DeepPartial } from \"@stryke/types/base\";\nimport defu from \"defu\";\nimport type { BuildOptions } from \"esbuild\";\nimport { build, OutputFile } from \"esbuild\";\nimport { createEsbuildPlugin } from \"unplugin\";\n\nexport type BundleOptions = DeepPartial<BuildOptions> & {\n  name?: string;\n  resolve?: DeepPartial<ResolveOptions>;\n};\n\n/**\n * Bundle a type definition to a module.\n *\n * @param context - The context object containing the environment paths.\n * @param file - The file path to bundle.\n * @param options - Optional overrides for the ESBuild configuration.\n * @returns A promise that resolves to the bundled module.\n */\nexport async function bundle<TContext extends UnresolvedContext>(\n  context: TContext,\n  file: string,\n  options: BundleOptions = {}\n): Promise<OutputFile> {\n  const path = await context.fs.resolve(file);\n  if (!path || !context.fs.existsSync(path)) {\n    throw new Error(\n      `Module not found: \"${file}\". Please check the path and try again.`\n    );\n  }\n\n  const result = await build(\n    defu(\n      {\n        entryPoints: [path],\n        write: false,\n        sourcemap: false,\n        splitting: false,\n        treeShaking: true,\n        bundle: true,\n        packages: \"bundle\",\n        platform: \"node\",\n        logLevel: \"silent\",\n        ...omit(options, [\"name\", \"resolve\"])\n      },\n      resolveOptions(context),\n      {\n        plugins: [\n          createEsbuildPlugin(\n            createUnpluginResolver(context, {\n              name: options.name ?? `${findFileName(file)} Bundler`,\n              prefix: false,\n              overrides: defu(\n                options.resolve ?? {},\n                { skipNodeModulesBundle: false },\n                context.config.resolve\n              ) as CreateUnpluginResolverOptions[\"overrides\"],\n              silenceHookLogging: true\n            })\n          )()\n        ]\n      }\n    )\n  );\n  if (result.errors.length > 0) {\n    throw new Error(\n      `Failed to bundle ${file}: ${result.errors\n        .map(error => error.text)\n        .join(\", \")}`\n    );\n  }\n  if (result.warnings.length > 0) {\n    context.warn(\n      `Warnings while bundling ${file}: ${result.warnings\n        .map(warning => warning.text)\n        .join(\", \")}`\n    );\n  }\n  if (!result.outputFiles || result.outputFiles.filter(Boolean).length === 0) {\n    throw new Error(\n      `No output files generated for ${\n        file\n      }. Please check the configuration and try again.`\n    );\n  }\n\n  return result.outputFiles.filter(Boolean)[0]!;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AA8CA,eAAsB,OACpB,SACA,MACA,UAAyB,EAAE,EACN;CACrB,MAAM,OAAO,MAAM,QAAQ,GAAG,QAAQ,KAAK;AAC3C,KAAI,CAAC,QAAQ,CAAC,QAAQ,GAAG,WAAW,KAAK,CACvC,OAAM,IAAI,MACR,sBAAsB,KAAK,yCAC5B;CAGH,MAAM,SAAS,MAAM,MACnB,KACE;EACE,aAAa,CAAC,KAAK;EACnB,OAAO;EACP,WAAW;EACX,WAAW;EACX,aAAa;EACb,QAAQ;EACR,UAAU;EACV,UAAU;EACV,UAAU;EACV,GAAG,KAAK,SAAS,CAAC,QAAQ,UAAU,CAAC;EACtC,EACD,eAAe,QAAQ,EACvB,EACE,SAAS,CACP,oBACE,uBAAuB,SAAS;EAC9B,MAAM,QAAQ,QAAQ,GAAG,aAAa,KAAK,CAAC;EAC5C,QAAQ;EACR,WAAW,KACT,QAAQ,WAAW,EAAE,EACrB,EAAE,uBAAuB,OAAO,EAChC,QAAQ,OAAO,QAChB;EACD,oBAAoB;EACrB,CAAC,CACH,EAAE,CACJ,EACF,CACF,CACF;AACD,KAAI,OAAO,OAAO,SAAS,EACzB,OAAM,IAAI,MACR,oBAAoB,KAAK,IAAI,OAAO,OACjC,KAAI,UAAS,MAAM,KAAK,CACxB,KAAK,KAAK,GACd;AAEH,KAAI,OAAO,SAAS,SAAS,EAC3B,SAAQ,KACN,2BAA2B,KAAK,IAAI,OAAO,SACxC,KAAI,YAAW,QAAQ,KAAK,CAC5B,KAAK,KAAK,GACd;AAEH,KAAI,CAAC,OAAO,eAAe,OAAO,YAAY,OAAO,QAAQ,CAAC,WAAW,EACvE,OAAM,IAAI,MACR,iCACE,KACD,iDACF;AAGH,QAAO,OAAO,YAAY,OAAO,QAAQ,CAAC"}

package/dist/codegen.cjs

@@ -0,0 +1,27 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
+let ajv = require("ajv");
+ajv = require_runtime.__toESM(ajv, 1);
+let ajv_dist_standalone_index_js = require("ajv/dist/standalone/index.js");
+ajv_dist_standalone_index_js = require_runtime.__toESM(ajv_dist_standalone_index_js, 1);
+
+//#region src/codegen.ts
+/**
+* Generates standalone validation code for the provided JSON schemas using the Ajv library. This function takes an array of JSON schemas and an optional set of references or functions, and returns a string containing the generated validation code. The generated code can be used to validate data against the provided schemas without requiring the Ajv library at runtime, making it suitable for use in environments where minimizing dependencies is important.
+*
+* @param schemas - An array of JSON schemas to generate validation code for. Each schema should be a valid JSON schema object that defines the structure and constraints of the data to be validated.
+* @param refsOrFuncts - An optional parameter that can be either an object containing schema references or a function that returns such an object. This parameter allows you to provide additional schemas that may be referenced by the main schemas, or to define custom functions that can be used in the generated validation code. If not provided, the function will generate code based solely on the provided schemas.
+* @returns A promise that resolves to a string containing the generated standalone validation code.
+*/
+async function generateCode(schemas, refsOrFuncts) {
+	return (0, ajv_dist_standalone_index_js.default)(new ajv.default({
+		schemas,
+		code: {
+			source: true,
+			esm: true
+		}
+	}), refsOrFuncts);
+}
+
+//#endregion
+exports.generateCode = generateCode;

package/dist/codegen.d.cts

@@ -0,0 +1,15 @@
+import { Options } from "ajv";
+import standaloneCode from "ajv/dist/standalone/index.js";
+
+//#region src/codegen.d.ts
+/**
+ * Generates standalone validation code for the provided JSON schemas using the Ajv library. This function takes an array of JSON schemas and an optional set of references or functions, and returns a string containing the generated validation code. The generated code can be used to validate data against the provided schemas without requiring the Ajv library at runtime, making it suitable for use in environments where minimizing dependencies is important.
+ *
+ * @param schemas - An array of JSON schemas to generate validation code for. Each schema should be a valid JSON schema object that defines the structure and constraints of the data to be validated.
+ * @param refsOrFuncts - An optional parameter that can be either an object containing schema references or a function that returns such an object. This parameter allows you to provide additional schemas that may be referenced by the main schemas, or to define custom functions that can be used in the generated validation code. If not provided, the function will generate code based solely on the provided schemas.
+ * @returns A promise that resolves to a string containing the generated standalone validation code.
+ */
+declare function generateCode(schemas: Options["schemas"], refsOrFuncts?: Parameters<typeof standaloneCode>[1]): Promise<string>;
+//#endregion
+export { generateCode };
+//# sourceMappingURL=codegen.d.cts.map

package/dist/codegen.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codegen.d.cts","names":[],"sources":["../src/codegen.ts"],"mappings":";;;;;;AA6BA;;;;;iBAAsB,YAAA,CACpB,OAAA,EAAS,OAAA,aACT,YAAA,GAAe,UAAA,QAAkB,cAAA,OAAkB,OAAA"}

package/dist/codegen.d.mts

@@ -0,0 +1,15 @@
+import { Options } from "ajv";
+import standaloneCode from "ajv/dist/standalone/index.js";
+
+//#region src/codegen.d.ts
+/**
+ * Generates standalone validation code for the provided JSON schemas using the Ajv library. This function takes an array of JSON schemas and an optional set of references or functions, and returns a string containing the generated validation code. The generated code can be used to validate data against the provided schemas without requiring the Ajv library at runtime, making it suitable for use in environments where minimizing dependencies is important.
+ *
+ * @param schemas - An array of JSON schemas to generate validation code for. Each schema should be a valid JSON schema object that defines the structure and constraints of the data to be validated.
+ * @param refsOrFuncts - An optional parameter that can be either an object containing schema references or a function that returns such an object. This parameter allows you to provide additional schemas that may be referenced by the main schemas, or to define custom functions that can be used in the generated validation code. If not provided, the function will generate code based solely on the provided schemas.
+ * @returns A promise that resolves to a string containing the generated standalone validation code.
+ */
+declare function generateCode(schemas: Options["schemas"], refsOrFuncts?: Parameters<typeof standaloneCode>[1]): Promise<string>;
+//#endregion
+export { generateCode };
+//# sourceMappingURL=codegen.d.mts.map

package/dist/codegen.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codegen.d.mts","names":[],"sources":["../src/codegen.ts"],"mappings":";;;;;;AA6BA;;;;;iBAAsB,YAAA,CACpB,OAAA,EAAS,OAAA,aACT,YAAA,GAAe,UAAA,QAAkB,cAAA,OAAkB,OAAA"}

package/dist/codegen.mjs

@@ -0,0 +1,24 @@
+import Ajv from "ajv";
+import standaloneCode from "ajv/dist/standalone/index.js";
+
+//#region src/codegen.ts
+/**
+* Generates standalone validation code for the provided JSON schemas using the Ajv library. This function takes an array of JSON schemas and an optional set of references or functions, and returns a string containing the generated validation code. The generated code can be used to validate data against the provided schemas without requiring the Ajv library at runtime, making it suitable for use in environments where minimizing dependencies is important.
+*
+* @param schemas - An array of JSON schemas to generate validation code for. Each schema should be a valid JSON schema object that defines the structure and constraints of the data to be validated.
+* @param refsOrFuncts - An optional parameter that can be either an object containing schema references or a function that returns such an object. This parameter allows you to provide additional schemas that may be referenced by the main schemas, or to define custom functions that can be used in the generated validation code. If not provided, the function will generate code based solely on the provided schemas.
+* @returns A promise that resolves to a string containing the generated standalone validation code.
+*/
+async function generateCode(schemas, refsOrFuncts) {
+	return standaloneCode(new Ajv({
+		schemas,
+		code: {
+			source: true,
+			esm: true
+		}
+	}), refsOrFuncts);
+}
+
+//#endregion
+export { generateCode };
+//# sourceMappingURL=codegen.mjs.map

package/dist/codegen.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"codegen.mjs","names":[],"sources":["../src/codegen.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                   ⚡ Storm Software - Powerlines\n\n This code was released as part of the Powerlines project. Powerlines\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/powerlines.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/powerlines\n Documentation:            https://docs.stormsoftware.com/projects/powerlines\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nimport type { Options } from \"ajv\";\nimport Ajv from \"ajv\";\nimport standaloneCode from \"ajv/dist/standalone\";\n\n/**\n * Generates standalone validation code for the provided JSON schemas using the Ajv library. This function takes an array of JSON schemas and an optional set of references or functions, and returns a string containing the generated validation code. The generated code can be used to validate data against the provided schemas without requiring the Ajv library at runtime, making it suitable for use in environments where minimizing dependencies is important.\n *\n * @param schemas - An array of JSON schemas to generate validation code for. Each schema should be a valid JSON schema object that defines the structure and constraints of the data to be validated.\n * @param refsOrFuncts - An optional parameter that can be either an object containing schema references or a function that returns such an object. This parameter allows you to provide additional schemas that may be referenced by the main schemas, or to define custom functions that can be used in the generated validation code. If not provided, the function will generate code based solely on the provided schemas.\n * @returns A promise that resolves to a string containing the generated standalone validation code.\n */\nexport async function generateCode(\n  schemas: Options[\"schemas\"],\n  refsOrFuncts?: Parameters<typeof standaloneCode>[1]\n) {\n  return standaloneCode(\n    new Ajv({\n      schemas,\n      code: { source: true, esm: true }\n    }),\n    refsOrFuncts\n  );\n}\n"],"mappings":";;;;;;;;;;;AA6BA,eAAsB,aACpB,SACA,cACA;AACA,QAAO,eACL,IAAI,IAAI;EACN;EACA,MAAM;GAAE,QAAQ;GAAM,KAAK;GAAM;EAClC,CAAC,EACF,aACD"}

package/dist/extract.cjs

@@ -1,13 +1,15 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
-const require_is_schema_definition = require('./is-schema-definition.cjs');
+const require_jtd = require('./jtd.cjs');
 const require_reflection = require('./reflection.cjs');
 const require_resolve = require('./resolve.cjs');
+const require_type_checks = require('./type-checks.cjs');
 let defu = require("defu");
 defu = require_runtime.__toESM(defu, 1);
 let _powerlines_core = require("@powerlines/core");
 let _powerlines_deepkit_esbuild_plugin = require("@powerlines/deepkit/esbuild-plugin");
 let _powerlines_deepkit_vendor_type = require("@powerlines/deepkit/vendor/type");
+let _stryke_hash = require("@stryke/hash");
 let _stryke_json = require("@stryke/json");
 let _stryke_type_checks = require("@stryke/type-checks");
 let _stryke_type_checks_is_set_object = require("@stryke/type-checks/is-set-object");
@@ -15,6 +17,34 @@ let _stryke_zod = require("@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 ((0, _stryke_type_checks.isSetString)(input)) return (0, _stryke_hash.murmurhash)({
+		variant,
+		input
+	});
+	else if ((0, _stryke_type_checks_is_set_object.isSetObject)(input)) {
+		if ((0, _stryke_zod.isZod3Type)(input)) return (0, _stryke_hash.murmurhash)({
+			variant,
+			input: input._def
+		});
+		else if ((0, _stryke_json.isStandardJsonSchema)(input)) return (0, _stryke_hash.murmurhash)({
+			variant,
+			input: input["~standard"]
+		});
+		else if ((0, _stryke_json.isJsonSchemaObjectType)(input)) return (0, _stryke_hash.murmurhash)({
+			variant,
+			input
+		});
+		else if ((0, _powerlines_deepkit_vendor_type.isType)(input)) return (0, _stryke_hash.murmurhash)({
+			variant,
+			input: (0, _powerlines_deepkit_vendor_type.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
@@ -28,89 +58,208 @@ function extractReflection(reflection) {
 	return require_reflection.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 ((0, _stryke_type_checks_is_set_object.isSetObject)(schema) && ((0, _stryke_zod.isZod3Type)(schema) || (0, _stryke_json.isStandardJsonSchema)(schema) || (0, _stryke_json.isJsonSchema7ObjectType)(schema))) {
+	if ((0, _stryke_type_checks_is_set_object.isSetObject)(schema) && ((0, _stryke_zod.isZod3Type)(schema) || (0, _stryke_json.isStandardJsonSchema)(schema) || (0, _stryke_json.isJsonSchemaObjectType)(schema) || require_type_checks.isUntypedInput(schema) || require_type_checks.isUntypedSchema(schema))) {
 		let jsonSchema;
-		if ((0, _stryke_zod.isZod3Type)(schema)) jsonSchema = (0, _stryke_zod.extractJsonSchema7)(schema);
-		else if ((0, _stryke_json.isStandardJsonSchema)(schema)) jsonSchema = schema["~standard"].jsonSchema.input({ target: "draft-07" });
+		if ((0, _stryke_zod.isZod3Type)(schema)) jsonSchema = (0, _stryke_zod.extractJsonSchema)(schema);
+		else if ((0, _stryke_json.isStandardJsonSchema)(schema)) jsonSchema = schema["~standard"].jsonSchema.input({ target: "draft-2020-12" });
+		else if (require_type_checks.isUntypedInput(schema)) jsonSchema = schema.$schema;
 		else jsonSchema = schema;
-		if ((0, _stryke_json.isJsonSchema7ObjectType)(jsonSchema)) return jsonSchema;
+		const jtd = require_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 ((0, _stryke_type_checks_is_set_object.isSetObject)(input)) {
-		if ((0, _stryke_zod.isZod3Type)(input)) {
-			const schema = extractJsonSchema(input);
-			if (schema) return {
-				schema,
-				variant: "zod3",
-				input
-			};
-		} else if ((0, _stryke_json.isStandardJsonSchema)(input)) {
-			const schema = extractJsonSchema(input);
-			if (schema) return {
-				schema,
-				variant: "standard-schema",
-				input
-			};
-		} else if ((0, _stryke_json.isJsonSchema7ObjectType)(input)) {
-			const schema = extractJsonSchema(input);
-			if (schema) return {
-				schema,
-				variant: "json-schema",
-				input
-			};
-		} else if ((0, _powerlines_deepkit_vendor_type.isType)(input)) {
-			const schema = extractReflection(input);
-			if (schema) return {
-				schema,
-				variant: "reflection",
-				input
-			};
-		}
+		if ((0, _stryke_zod.isZod3Type)(input)) return "zod3";
+		else if ((0, _stryke_json.isStandardJsonSchema)(input)) return "standard-schema";
+		else if (require_type_checks.isJTDSchema(input)) return "jtd-schema";
+		else if ((0, _stryke_json.isJsonSchemaObjectType)(input)) return "json-schema";
+		else if ((0, _powerlines_deepkit_vendor_type.isType)(input)) return "reflection";
+		else if (require_type_checks.isUntypedInput(input) || require_type_checks.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 ((0, _stryke_type_checks.isSetString)(input) || (0, _powerlines_core.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 (require_type_checks.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 = require_jtd.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 (require_type_checks.isExtractedSchema(input)) return input;
+	if (require_type_checks.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 require_resolve.resolve(context, input, (0, defu.default)(options, { plugins: [(0, _powerlines_deepkit_esbuild_plugin.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 (require_is_schema_definition.isSchemaDefinition(input)) return input;
-	let inputObject = input;
-	if ((0, _stryke_type_checks.isSetString)(input) || (0, _powerlines_core.isTypeDefinition)(input)) inputObject = await require_resolve.resolve(context, input, (0, defu.default)(options, { plugins: [(0, _powerlines_deepkit_esbuild_plugin.esbuildPlugin)(context, {
-		reflection: "default",
-		level: "all"
-	})] }));
-	return extractSchema(inputObject);
+	return await extractSchema(context, input, options);
 }
 
 //#endregion
 exports.extract = extract;
+exports.extractHash = extractHash;
 exports.extractJsonSchema = extractJsonSchema;
 exports.extractReflection = extractReflection;
-exports.extractSchema = extractSchema;
+exports.extractResolvedVariant = extractResolvedVariant;
+exports.extractSchema = extractSchema;
+exports.extractSchemaSchema = extractSchemaSchema;
+exports.extractSource = extractSource;
+exports.extractVariant = extractVariant;