@powerlines/schema 0.11.27 → 0.11.37

package/dist/codegen.mjs.map

@@ -1 +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 { toBool } from \"@stryke/convert/to-bool\";\nimport { isBoolean } from \"@stryke/type-checks/is-boolean\";\nimport { isNull } from \"@stryke/type-checks/is-null\";\nimport { isNumber } from \"@stryke/type-checks/is-number\";\nimport { isUndefined } from \"@stryke/type-checks/is-undefined\";\nimport type { Options } from \"ajv/lib/jtd\";\nimport Ajv from \"ajv/lib/jtd\";\nimport standaloneCode from \"ajv/lib/standalone\";\nimport { getProperties } from \"./helpers\";\nimport { JTDSchemaType, JTDType } from \"./types\";\n\n/**\n * Stringifies a value as a string.\n *\n * @remarks\n * This function is used to convert a value into a string representation that can be used in generated code, such as default values in TypeScript declarations. It handles different types of values, including booleans, numbers, and strings, and formats them appropriately. For example, boolean values are converted to \"true\" or \"false\", numbers are formatted with locale-specific separators, and strings are JSON-stringified with escaped quotes. The function also takes into account the type of the value when stringifying, allowing for specific formatting based on the type (e.g., different handling for integers vs. floats). This ensures that the generated code is both accurate and readable.\n *\n * @param value - The value to stringify.\n * @returns A string representation of the value.\n */\nexport function stringifyValue(value?: unknown, type?: JTDType): string {\n  return isUndefined(value)\n    ? \"undefined\"\n    : isNull(value)\n      ? \"null\"\n      : type === \"boolean\" || isBoolean(value)\n        ? String(toBool(value))\n        : type && type.startsWith(\"float\")\n          ? Number.parseFloat(String(value)).toLocaleString(undefined, {\n              maximumFractionDigits: 20\n            })\n          : (type && [\"int\", \"uint\"].some(prefix => type.startsWith(prefix))) ||\n              isNumber(value)\n            ? Number.parseInt(String(value)).toLocaleString()\n            : type === \"timestamp\"\n              ? `\"${new Date(String(value)).toISOString()}\"`\n              : JSON.stringify(\n                  String(value).replaceAll('\"', '\\\\\"'),\n                  undefined,\n                  2\n                );\n}\n\n/**\n * Stringifies a JTD schema type into a string representation. This function takes a JTD schema type as input and returns a string that represents the type in a human-readable format. It handles various JTD schema constructs, such as references, primitive types, enums, arrays, objects, and discriminated unions. The resulting string can be used for documentation, error messages, or any context where a textual representation of the schema type is needed. The function recursively processes nested schemas to ensure that complex types are accurately represented in the output string.\n *\n * @param schema - The JTD schema type to stringify.\n * @returns A string representation of the JTD schema type.\n */\nexport function stringifyType(schema?: JTDSchemaType): string {\n  if (!schema) {\n    return \"unknown\";\n  }\n\n  if (\"ref\" in schema) {\n    return schema.ref;\n  }\n\n  if (\"type\" in schema) {\n    return [\"float\", \"uint\", \"int\"].some(prefix =>\n      schema.type.startsWith(prefix)\n    )\n      ? \"number\"\n      : schema.type === \"timestamp\"\n        ? \"string\"\n        : schema.type;\n  }\n\n  if (\"enum\" in schema) {\n    return schema.enum.map(value => JSON.stringify(value)).join(\" | \");\n  }\n\n  if (\"elements\" in schema) {\n    return `${stringifyType(schema.elements)}[]`;\n  }\n\n  if (\"values\" in schema) {\n    return `{ [key: string]: ${stringifyType(schema.values)} }`;\n  }\n\n  if (\"properties\" in schema || \"optionalProperties\" in schema) {\n    return `{ ${Object.entries(getProperties(schema))\n      .map(([key, value]) => {\n        return `${key}${value.optional ? \"?\" : \"\"}: ${stringifyType(value)}`;\n      })\n      .join(\";\\n\")} }`;\n  }\n\n  if (\"discriminator\" in schema) {\n    return \"object\";\n  }\n\n  return \"unknown\";\n}\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":";;;;;;;;;;;;;;;;;;;AAsCA,SAAgB,eAAe,OAAiB,MAAwB;CACtE,OAAO,YAAY,KAAK,IACpB,cACA,OAAO,KAAK,IACV,SACA,SAAS,aAAa,UAAU,KAAK,IACnC,OAAO,OAAO,KAAK,CAAC,IACpB,QAAQ,KAAK,WAAW,OAAO,IAC7B,OAAO,WAAW,OAAO,KAAK,CAAC,EAAE,eAAe,QAAW,EACzD,uBAAuB,GACzB,CAAC,IACA,QAAQ,CAAC,OAAO,MAAM,EAAE,MAAK,WAAU,KAAK,WAAW,MAAM,CAAC,KAC7D,SAAS,KAAK,IACd,OAAO,SAAS,OAAO,KAAK,CAAC,EAAE,eAAe,IAC9C,SAAS,cACP,IAAI,IAAI,KAAK,OAAO,KAAK,CAAC,EAAE,YAAY,EAAE,KAC1C,KAAK,UACH,OAAO,KAAK,EAAE,WAAW,MAAK,MAAK,GACnC,QACA,CACF;AAChB;;;;;;;AAQA,SAAgB,cAAc,QAAgC;CAC5D,IAAI,CAAC,QACH,OAAO;CAGT,IAAI,SAAS,QACX,OAAO,OAAO;CAGhB,IAAI,UAAU,QACZ,OAAO;EAAC;EAAS;EAAQ;CAAK,EAAE,MAAK,WACnC,OAAO,KAAK,WAAW,MAAM,CAC/B,IACI,WACA,OAAO,SAAS,cACd,WACA,OAAO;CAGf,IAAI,UAAU,QACZ,OAAO,OAAO,KAAK,KAAI,UAAS,KAAK,UAAU,KAAK,CAAC,EAAE,KAAK,KAAK;CAGnE,IAAI,cAAc,QAChB,OAAO,GAAG,cAAc,OAAO,QAAQ,EAAE;CAG3C,IAAI,YAAY,QACd,OAAO,oBAAoB,cAAc,OAAO,MAAM,EAAE;CAG1D,IAAI,gBAAgB,UAAU,wBAAwB,QACpD,OAAO,KAAK,OAAO,QAAQ,cAAc,MAAM,CAAC,EAC7C,KAAK,CAAC,KAAK,WAAW;EACrB,OAAO,GAAG,MAAM,MAAM,WAAW,MAAM,GAAG,IAAI,cAAc,KAAK;CACnE,CAAC,EACA,KAAK,KAAK,EAAE;CAGjB,IAAI,mBAAmB,QACrB,OAAO;CAGT,OAAO;AACT;;;;;;;;AASA,eAAsB,aACpB,SACA,cACA;CACA,OAAO,eACL,IAAI,IAAI;EACN;EACA,MAAM;GAAE,QAAQ;GAAM,KAAK;EAAK;CAClC,CAAC,GACD,YACF;AACF"}
+{"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 { toBool } from \"@stryke/convert/to-bool\";\nimport { isBoolean } from \"@stryke/type-checks/is-boolean\";\nimport { isNull } from \"@stryke/type-checks/is-null\";\nimport { isNumber } from \"@stryke/type-checks/is-number\";\nimport { isSetString } from \"@stryke/type-checks/is-set-string\";\nimport { isUndefined } from \"@stryke/type-checks/is-undefined\";\nimport type { Options } from \"ajv\";\nimport Ajv from \"ajv\";\nimport { formatNames, fullFormats } from \"ajv-formats/dist/formats\";\nimport { _, Name } from \"ajv/dist/compile/codegen\";\nimport standaloneCode from \"ajv/dist/standalone\";\nimport { getPropertiesList } from \"./helpers\";\nimport { getPrimarySchemaType, isSchemaNullable } from \"./metadata\";\nimport { isJsonSchemaObject } from \"./type-checks\";\nimport { JsonSchema, JsonSchemaPrimitiveType } from \"./types\";\n\n/**\n * Stringifies a value for generated TypeScript code.\n */\nexport function stringifyValue(\n  value?: unknown,\n  type?: JsonSchemaPrimitiveType | string\n): string {\n  return isUndefined(value)\n    ? \"undefined\"\n    : isNull(value)\n      ? \"null\"\n      : type === \"boolean\" || isBoolean(value)\n        ? String(toBool(value))\n        : type === \"number\" || isNumber(value)\n          ? Number.parseFloat(String(value)).toLocaleString(undefined, {\n              maximumFractionDigits: 20\n            })\n          : type === \"integer\"\n            ? Number.parseInt(String(value)).toLocaleString()\n            : JSON.stringify(value);\n}\n\n/**\n * Stringifies a JSON Schema fragment into a TypeScript-like type string.\n */\nexport function stringifyType<T = unknown>(schema?: JsonSchema<T>): string {\n  if (!schema) {\n    return \"unknown\";\n  }\n\n  if (isSetString(schema.$ref)) {\n    const match = /^#\\/(?:definitions|\\$defs)\\/(.+)$/.exec(schema.$ref);\n\n    return match?.[1] ?? schema.$ref;\n  }\n\n  const primaryType = getPrimarySchemaType(schema);\n  if (primaryType) {\n    if (primaryType === \"integer\" || primaryType === \"number\") {\n      return \"number\";\n    }\n\n    return primaryType;\n  }\n\n  if (Array.isArray(schema.enum)) {\n    return schema.enum.map(value => JSON.stringify(value)).join(\" | \");\n  }\n\n  if (schema.const !== undefined) {\n    return JSON.stringify(schema.const);\n  }\n\n  if (schema.type === \"array\" || schema.items) {\n    const items = Array.isArray(schema.items) ? schema.items[0] : schema.items;\n\n    return `${stringifyType(items)}[]`;\n  }\n\n  if (\n    schema.type === \"object\" ||\n    schema.properties ||\n    schema.additionalProperties\n  ) {\n    if (\n      schema.additionalProperties &&\n      typeof schema.additionalProperties === \"object\"\n    ) {\n      return `{ [key: string]: ${stringifyType(schema.additionalProperties)} }`;\n    }\n\n    if (isJsonSchemaObject(schema)) {\n      return `{ ${getPropertiesList(schema as JsonSchema<Record<string, any>>)\n        .map(property => {\n          const suffix =\n            property.optional || property.nullable\n              ? `${property.optional ? \"?\" : \"\"}${property.nullable ? \" | null\" : \"\"}`\n              : \"\";\n\n          return `${property.key}${suffix}: ${stringifyType(property.value)}`;\n        })\n        .join(\";\\n\")} }`;\n    }\n  }\n\n  if (schema.oneOf || schema.anyOf) {\n    return ((schema.oneOf ?? schema.anyOf ?? []) as JsonSchema<T>[])\n      .map(branch => stringifyType(branch))\n      .join(\" | \");\n  }\n\n  if (schema.allOf) {\n    return \"object\";\n  }\n\n  return \"unknown\";\n}\n\n/**\n * Generates standalone JSON Schema validation code using Ajv.\n */\nexport async function generateCode(\n  schemas: Options[\"schemas\"],\n  refsOrFuncts?: Parameters<typeof standaloneCode>[1]\n) {\n  const ajv = new Ajv({\n    schemas,\n    code: { source: true, esm: true }\n  });\n\n  ajv.opts.code.formats ??= _`await import(\"ajv-formats/dist/formats\").${new Name(\n    \"fullFormats\"\n  )}`;\n  for (const formatName of formatNames) {\n    ajv.addFormat(formatName, fullFormats[formatName]);\n  }\n\n  return standaloneCode(ajv, refsOrFuncts);\n}\n\nexport function isNullableSchema(schema?: JsonSchema): boolean {\n  return isSchemaNullable(schema);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAqCA,SAAgB,eACd,OACA,MACQ;CACR,OAAO,YAAY,KAAK,IACpB,cACA,OAAO,KAAK,IACV,SACA,SAAS,aAAa,UAAU,KAAK,IACnC,OAAO,OAAO,KAAK,CAAC,IACpB,SAAS,YAAY,SAAS,KAAK,IACjC,OAAO,WAAW,OAAO,KAAK,CAAC,EAAE,eAAe,QAAW,EACzD,uBAAuB,GACzB,CAAC,IACD,SAAS,YACP,OAAO,SAAS,OAAO,KAAK,CAAC,EAAE,eAAe,IAC9C,KAAK,UAAU,KAAK;AAClC;;;;AAKA,SAAgB,cAA2B,QAAgC;CACzE,IAAI,CAAC,QACH,OAAO;CAGT,IAAI,YAAY,OAAO,IAAI,GAGzB,OAFc,oCAAoC,KAAK,OAAO,IAEnD,IAAI,MAAM,OAAO;CAG9B,MAAM,cAAc,qBAAqB,MAAM;CAC/C,IAAI,aAAa;EACf,IAAI,gBAAgB,aAAa,gBAAgB,UAC/C,OAAO;EAGT,OAAO;CACT;CAEA,IAAI,MAAM,QAAQ,OAAO,IAAI,GAC3B,OAAO,OAAO,KAAK,KAAI,UAAS,KAAK,UAAU,KAAK,CAAC,EAAE,KAAK,KAAK;CAGnE,IAAI,OAAO,UAAU,QACnB,OAAO,KAAK,UAAU,OAAO,KAAK;CAGpC,IAAI,OAAO,SAAS,WAAW,OAAO,OAGpC,OAAO,GAAG,cAFI,MAAM,QAAQ,OAAO,KAAK,IAAI,OAAO,MAAM,KAAK,OAAO,KAExC,EAAE;CAGjC,IACE,OAAO,SAAS,YAChB,OAAO,cACP,OAAO,sBACP;EACA,IACE,OAAO,wBACP,OAAO,OAAO,yBAAyB,UAEvC,OAAO,oBAAoB,cAAc,OAAO,oBAAoB,EAAE;EAGxE,IAAI,mBAAmB,MAAM,GAC3B,OAAO,KAAK,kBAAkB,MAAyC,EACpE,KAAI,aAAY;GACf,MAAM,SACJ,SAAS,YAAY,SAAS,WAC1B,GAAG,SAAS,WAAW,MAAM,KAAK,SAAS,WAAW,YAAY,OAClE;GAEN,OAAO,GAAG,SAAS,MAAM,OAAO,IAAI,cAAc,SAAS,KAAK;EAClE,CAAC,EACA,KAAK,KAAK,EAAE;CAEnB;CAEA,IAAI,OAAO,SAAS,OAAO,OACzB,QAAS,OAAO,SAAS,OAAO,SAAS,CAAC,GACvC,KAAI,WAAU,cAAc,MAAM,CAAC,EACnC,KAAK,KAAK;CAGf,IAAI,OAAO,OACT,OAAO;CAGT,OAAO;AACT;;;;AAKA,eAAsB,aACpB,SACA,cACA;CACA,MAAM,MAAM,IAAI,IAAI;EAClB;EACA,MAAM;GAAE,QAAQ;GAAM,KAAK;EAAK;CAClC,CAAC;CAED,IAAI,KAAK,KAAK,YAAY,CAAC,4CAA4C,IAAI,KACzE,aACF;CACA,KAAK,MAAM,cAAc,aACvB,IAAI,UAAU,YAAY,YAAY,WAAW;CAGnD,OAAO,eAAe,KAAK,YAAY;AACzC;AAEA,SAAgB,iBAAiB,QAA8B;CAC7D,OAAO,iBAAiB,MAAM;AAChC"}

package/dist/constants.cjs

@@ -1,19 +1,42 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 //#region src/constants.ts
-const JTDTypes = {
+const JsonSchemaTypes = {
 	STRING: "string",
-	TIMESTAMP: "timestamp",
+	NUMBER: "number",
+	INTEGER: "integer",
 	BOOLEAN: "boolean",
-	FLOAT32: "float32",
-	FLOAT64: "float64",
-	INT8: "int8",
-	UINT8: "uint8",
-	INT16: "int16",
-	UINT16: "uint16",
-	INT32: "int32",
-	UINT32: "uint32"
+	NULL: "null",
+	OBJECT: "object",
+	ARRAY: "array"
 };
+const JSON_SCHEMA_DATA_TYPES = [
+	JsonSchemaTypes.STRING,
+	JsonSchemaTypes.NUMBER,
+	JsonSchemaTypes.INTEGER,
+	JsonSchemaTypes.BOOLEAN,
+	JsonSchemaTypes.ARRAY,
+	JsonSchemaTypes.OBJECT,
+	JsonSchemaTypes.NULL
+];
+const JSON_SCHEMA_METADATA_KEYS = [
+	"docs",
+	"deprecated",
+	"title",
+	"description",
+	"examples",
+	"visibility",
+	"hidden",
+	"ignore",
+	"internal",
+	"runtime",
+	"readOnly",
+	"writeOnly",
+	"alias",
+	"tags"
+];
 
 //#endregion
-exports.JTDTypes = JTDTypes;
+exports.JSON_SCHEMA_DATA_TYPES = JSON_SCHEMA_DATA_TYPES;
+exports.JSON_SCHEMA_METADATA_KEYS = JSON_SCHEMA_METADATA_KEYS;
+exports.JsonSchemaTypes = JsonSchemaTypes;

package/dist/constants.d.cts

@@ -1,17 +1,15 @@
 //#region src/constants.d.ts
-declare const JTDTypes: {
+declare const JsonSchemaTypes: {
   readonly STRING: "string";
-  readonly TIMESTAMP: "timestamp";
+  readonly NUMBER: "number";
+  readonly INTEGER: "integer";
   readonly BOOLEAN: "boolean";
-  readonly FLOAT32: "float32";
-  readonly FLOAT64: "float64";
-  readonly INT8: "int8";
-  readonly UINT8: "uint8";
-  readonly INT16: "int16";
-  readonly UINT16: "uint16";
-  readonly INT32: "int32";
-  readonly UINT32: "uint32";
+  readonly NULL: "null";
+  readonly OBJECT: "object";
+  readonly ARRAY: "array";
 };
+declare const JSON_SCHEMA_DATA_TYPES: readonly ["string", "number", "integer", "boolean", "array", "object", "null"];
+declare const JSON_SCHEMA_METADATA_KEYS: ("title" | "description" | "docs" | "examples" | "alias" | "tags" | "visibility" | "deprecated" | "hidden" | "ignore" | "internal" | "runtime" | "readOnly" | "writeOnly")[];
 //#endregion
-export { JTDTypes };
+export { JSON_SCHEMA_DATA_TYPES, JSON_SCHEMA_METADATA_KEYS, JsonSchemaTypes };
 //# sourceMappingURL=constants.d.cts.map

package/dist/constants.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.cts","names":[],"sources":["../src/constants.ts"],"mappings":";cAkBa,QAAA;EAAA"}
+{"version":3,"file":"constants.d.cts","names":[],"sources":["../src/constants.ts"],"mappings":";cAoBa,eAAA;EAAA;;;;;;;;cAUA,sBAAA;AAAA,cAUA,yBAAA"}

package/dist/constants.d.mts

@@ -1,17 +1,15 @@
 //#region src/constants.d.ts
-declare const JTDTypes: {
+declare const JsonSchemaTypes: {
   readonly STRING: "string";
-  readonly TIMESTAMP: "timestamp";
+  readonly NUMBER: "number";
+  readonly INTEGER: "integer";
   readonly BOOLEAN: "boolean";
-  readonly FLOAT32: "float32";
-  readonly FLOAT64: "float64";
-  readonly INT8: "int8";
-  readonly UINT8: "uint8";
-  readonly INT16: "int16";
-  readonly UINT16: "uint16";
-  readonly INT32: "int32";
-  readonly UINT32: "uint32";
+  readonly NULL: "null";
+  readonly OBJECT: "object";
+  readonly ARRAY: "array";
 };
+declare const JSON_SCHEMA_DATA_TYPES: readonly ["string", "number", "integer", "boolean", "array", "object", "null"];
+declare const JSON_SCHEMA_METADATA_KEYS: ("title" | "description" | "docs" | "examples" | "alias" | "tags" | "visibility" | "deprecated" | "hidden" | "ignore" | "internal" | "runtime" | "readOnly" | "writeOnly")[];
 //#endregion
-export { JTDTypes };
+export { JSON_SCHEMA_DATA_TYPES, JSON_SCHEMA_METADATA_KEYS, JsonSchemaTypes };
 //# sourceMappingURL=constants.d.mts.map

package/dist/constants.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.mts","names":[],"sources":["../src/constants.ts"],"mappings":";cAkBa,QAAA;EAAA"}
+{"version":3,"file":"constants.d.mts","names":[],"sources":["../src/constants.ts"],"mappings":";cAoBa,eAAA;EAAA;;;;;;;;cAUA,sBAAA;AAAA,cAUA,yBAAA"}

package/dist/constants.mjs

@@ -1,18 +1,39 @@
 //#region src/constants.ts
-const JTDTypes = {
+const JsonSchemaTypes = {
 	STRING: "string",
-	TIMESTAMP: "timestamp",
+	NUMBER: "number",
+	INTEGER: "integer",
 	BOOLEAN: "boolean",
-	FLOAT32: "float32",
-	FLOAT64: "float64",
-	INT8: "int8",
-	UINT8: "uint8",
-	INT16: "int16",
-	UINT16: "uint16",
-	INT32: "int32",
-	UINT32: "uint32"
+	NULL: "null",
+	OBJECT: "object",
+	ARRAY: "array"
 };
+const JSON_SCHEMA_DATA_TYPES = [
+	JsonSchemaTypes.STRING,
+	JsonSchemaTypes.NUMBER,
+	JsonSchemaTypes.INTEGER,
+	JsonSchemaTypes.BOOLEAN,
+	JsonSchemaTypes.ARRAY,
+	JsonSchemaTypes.OBJECT,
+	JsonSchemaTypes.NULL
+];
+const JSON_SCHEMA_METADATA_KEYS = [
+	"docs",
+	"deprecated",
+	"title",
+	"description",
+	"examples",
+	"visibility",
+	"hidden",
+	"ignore",
+	"internal",
+	"runtime",
+	"readOnly",
+	"writeOnly",
+	"alias",
+	"tags"
+];
 
 //#endregion
-export { JTDTypes };
+export { JSON_SCHEMA_DATA_TYPES, JSON_SCHEMA_METADATA_KEYS, JsonSchemaTypes };
 //# sourceMappingURL=constants.mjs.map

package/dist/constants.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"constants.mjs","names":[],"sources":["../src/constants.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\nexport const JTDTypes = {\n  STRING: \"string\",\n  TIMESTAMP: \"timestamp\",\n  BOOLEAN: \"boolean\",\n  FLOAT32: \"float32\",\n  FLOAT64: \"float64\",\n  INT8: \"int8\",\n  UINT8: \"uint8\",\n  INT16: \"int16\",\n  UINT16: \"uint16\",\n  INT32: \"int32\",\n  UINT32: \"uint32\"\n} as const;\n"],"mappings":";AAkBA,MAAa,WAAW;CACtB,QAAQ;CACR,WAAW;CACX,SAAS;CACT,SAAS;CACT,SAAS;CACT,MAAM;CACN,OAAO;CACP,OAAO;CACP,QAAQ;CACR,OAAO;CACP,QAAQ;AACV"}
+{"version":3,"file":"constants.mjs","names":[],"sources":["../src/constants.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 { SchemaMetadata } from \"./types\";\n\nexport const JsonSchemaTypes = {\n  STRING: \"string\",\n  NUMBER: \"number\",\n  INTEGER: \"integer\",\n  BOOLEAN: \"boolean\",\n  NULL: \"null\",\n  OBJECT: \"object\",\n  ARRAY: \"array\"\n} as const;\n\nexport const JSON_SCHEMA_DATA_TYPES = [\n  JsonSchemaTypes.STRING,\n  JsonSchemaTypes.NUMBER,\n  JsonSchemaTypes.INTEGER,\n  JsonSchemaTypes.BOOLEAN,\n  JsonSchemaTypes.ARRAY,\n  JsonSchemaTypes.OBJECT,\n  JsonSchemaTypes.NULL\n] as const;\n\nexport const JSON_SCHEMA_METADATA_KEYS = [\n  \"docs\",\n  \"deprecated\",\n  \"title\",\n  \"description\",\n  \"examples\",\n  \"visibility\",\n  \"hidden\",\n  \"ignore\",\n  \"internal\",\n  \"runtime\",\n  \"readOnly\",\n  \"writeOnly\",\n  \"alias\",\n  \"tags\"\n] satisfies ReadonlyArray<keyof SchemaMetadata>;\n"],"mappings":";AAoBA,MAAa,kBAAkB;CAC7B,QAAQ;CACR,QAAQ;CACR,SAAS;CACT,SAAS;CACT,MAAM;CACN,QAAQ;CACR,OAAO;AACT;AAEA,MAAa,yBAAyB;CACpC,gBAAgB;CAChB,gBAAgB;CAChB,gBAAgB;CAChB,gBAAgB;CAChB,gBAAgB;CAChB,gBAAgB;CAChB,gBAAgB;AAClB;AAEA,MAAa,4BAA4B;CACvC;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF"}

package/dist/extract.cjs

@@ -1,25 +1,94 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
 const require_type_checks = require('./type-checks.cjs');
-const require_jtd = require('./jtd.cjs');
 const require_persistence = require('./persistence.cjs');
 const require_reflection = require('./reflection.cjs');
 const require_resolve = require('./resolve.cjs');
 let defu = require("defu");
 defu = require_runtime.__toESM(defu, 1);
 let _stryke_type_checks = require("@stryke/type-checks");
+let _stryke_type_checks_is_set_object = require("@stryke/type-checks/is-set-object");
+let _stryke_json = require("@stryke/json");
 let _powerlines_core = require("@powerlines/core");
-let _powerlines_deepkit_esbuild_plugin = require("@powerlines/deepkit/esbuild-plugin");
+let _powerlines_deepkit_rolldown_plugin = require("@powerlines/deepkit/rolldown-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_path_join = require("@stryke/path/join");
-let _stryke_type_checks_is_set_object = require("@stryke/type-checks/is-set-object");
 let _stryke_zod = require("@stryke/zod");
 
 //#region src/extract.ts
+function convertNestedUntypedSchema(value) {
+	if (require_type_checks.isUntypedSchema(value)) return convertUntypedSchemaToJsonSchema(value);
+	if ((0, _stryke_type_checks_is_set_object.isSetObject)(value)) {
+		if (require_type_checks.isUntypedInput(value)) return convertUntypedInputToJsonSchema(value);
+		const nested = value;
+		if ("$schema" in nested && require_type_checks.isUntypedSchema(nested.$schema)) return convertUntypedSchemaToJsonSchema(nested.$schema);
+	}
+	return value;
+}
+function convertNestedUntypedSchemaArray(value) {
+	if (!Array.isArray(value)) return value;
+	return value.map((item) => convertNestedUntypedSchema(item));
+}
+function convertUntypedSchemaToJsonSchema(schema) {
+	const source = schema;
+	const jsonSchema = {};
+	for (const [key, value] of Object.entries(source)) {
+		if (key === "tsType" || key === "markdownType" || key === "tags" || key === "args" || key === "resolve") continue;
+		if (key === "id" && (0, _stryke_type_checks.isSetString)(value)) {
+			jsonSchema.$id = value;
+			continue;
+		}
+		if (key === "properties" || key === "patternProperties" || key === "dependentSchemas" || key === "$defs" || key === "definitions") {
+			if (!(0, _stryke_type_checks_is_set_object.isSetObject)(value)) {
+				jsonSchema[key] = value;
+				continue;
+			}
+			jsonSchema[key] = Object.fromEntries(Object.entries(value).map(([propertyKey, propertyValue]) => [propertyKey, convertNestedUntypedSchema(propertyValue)]));
+			continue;
+		}
+		if (key === "items" || key === "contains" || key === "if" || key === "then" || key === "else" || key === "not" || key === "propertyNames" || key === "additionalProperties" || key === "unevaluatedProperties") {
+			jsonSchema[key] = convertNestedUntypedSchema(value);
+			continue;
+		}
+		if (key === "oneOf" || key === "anyOf" || key === "allOf") {
+			jsonSchema[key] = convertNestedUntypedSchemaArray(value);
+			continue;
+		}
+		jsonSchema[key] = value;
+	}
+	return jsonSchema;
+}
+function convertUntypedInputToJsonSchema(input) {
+	const inputObject = input;
+	const base = require_type_checks.isUntypedSchema(inputObject.$schema) ? convertUntypedSchemaToJsonSchema(inputObject.$schema) : {};
+	const properties = {};
+	for (const [key, value] of Object.entries(inputObject)) {
+		if (key.startsWith("$")) continue;
+		if (!(0, _stryke_type_checks_is_set_object.isSetObject)(value)) continue;
+		if (require_type_checks.isUntypedInput(value)) {
+			properties[key] = convertUntypedInputToJsonSchema(value);
+			continue;
+		}
+		const nested = value;
+		if ("$schema" in nested && require_type_checks.isUntypedSchema(nested.$schema)) {
+			properties[key] = convertUntypedSchemaToJsonSchema(nested.$schema);
+			continue;
+		}
+		if (require_type_checks.isUntypedSchema(value)) properties[key] = convertUntypedSchemaToJsonSchema(value);
+	}
+	const mergedProperties = {
+		...(0, _stryke_type_checks_is_set_object.isSetObject)(base.properties) ? base.properties : {},
+		...properties
+	};
+	return {
+		...base,
+		type: base.type ?? "object",
+		...Object.keys(mergedProperties).length > 0 ? { properties: mergedProperties } : {}
+	};
+}
 /**
-* Creates a hash string for a given schema definition input. The function checks the type of the input and generates a hash based on its content. If the input is a Zod schema, it hashes the JSON representation of its internal definition. If the input is a Standard JSON Schema, it hashes the JSON representation of its internal standard schema. If the input is already a JSON Schema object, it hashes its JSON representation directly. If the input is a reflected Deepkit Type object, it hashes its JSON representation. The resulting hash string can be used for caching or comparison purposes.
+* Creates a hash string for a given schema definition input.
 */
 function extractHash(variant, input) {
 	if ((0, _stryke_type_checks.isSetString)(input)) return (0, _stryke_hash.murmurhash)({
@@ -35,10 +104,18 @@ function extractHash(variant, input) {
 			variant,
 			input: input["~standard"]
 		});
-		else if ((0, _stryke_json.isJsonSchemaObjectType)(input)) return (0, _stryke_hash.murmurhash)({
+		else if (require_type_checks.isJsonSchema(input)) return (0, _stryke_hash.murmurhash)({
 			variant,
 			input
 		});
+		else if (require_type_checks.isUntypedInput(input)) return (0, _stryke_hash.murmurhash)({
+			variant,
+			input: convertUntypedInputToJsonSchema(input)
+		});
+		else if (require_type_checks.isUntypedSchema(input)) return (0, _stryke_hash.murmurhash)({
+			variant,
+			input: convertUntypedSchemaToJsonSchema(input)
+		});
 		else if ((0, _powerlines_deepkit_vendor_type.isType)(input)) return (0, _stryke_hash.murmurhash)({
 			variant,
 			input: (0, _powerlines_deepkit_vendor_type.stringifyType)(input)
@@ -47,95 +124,47 @@ function extractHash(variant, input) {
 	throw new Error(`Failed to create an input hash for the provided schema definition input. The input must be a Zod schema, a Standard JSON Schema, a JSON Schema object, or a reflected Deepkit Type object.`);
 }
 /**
-* Converts a reflected Deepkit {@link @powerlines/deepkit/vendor/type#Type} into a JSON Schema (draft-07) representation.
-*
-* @remarks
-* This function delegates to an internal recursive walker that handles the full set of Deepkit reflection kinds.
-*
-* @param reflection - The reflected Deepkit Type to convert.
-* @returns A JSON Schema (draft-07) fragment representing the type, or `undefined` when no schema could be produced.
+* Converts a reflected Deepkit {@link Type} into a JSON Schema (draft-07) representation.
 */
 function extractReflection(reflection) {
 	if (!(0, _powerlines_deepkit_vendor_type.isType)(reflection)) return;
 	return require_reflection.reflectionToJsonSchema(reflection);
 }
 /**
-* Extracts a JSON Type Definition (RFC 8927) schema from a given schema definition, if possible.
-*
-* @remarks
-* This function checks if the provided input is a Zod schema, a Standard JSON Schema, or already a JSON Schema object, extracts a JSON Schema fragment via the appropriate adapter (Zod and Standard Schema produce draft-07 fragments), and then converts that fragment into a valid JTD form suitable for AJV's JTD validator.
-*
-* @param schema - The schema definition to extract from. This can be a Zod schema, a Standard JSON Schema, or a JSON Schema object.
-* @returns The extracted JTD schema if successful, otherwise undefined.
+* Extracts a JSON Schema from Zod, Standard Schema, untyped, or JSON Schema inputs.
 */
 function extractJsonSchema(schema) {
-	if ((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.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;
-		const jtd = require_jtd.jsonSchemaToJtd(jsonSchema);
-		if (jtd) return jtd;
+	if ((0, _stryke_type_checks_is_set_object.isSetObject)(schema) && ((0, _stryke_zod.isZod3Type)(schema) || (0, _stryke_json.isStandardJsonSchema)(schema) || require_type_checks.isJsonSchema(schema) || require_type_checks.isUntypedInput(schema) || require_type_checks.isUntypedSchema(schema))) {
+		if ((0, _stryke_zod.isZod3Type)(schema)) return (0, _stryke_zod.extractJsonSchema)(schema);
+		if ((0, _stryke_json.isStandardJsonSchema)(schema)) return schema["~standard"].jsonSchema.input({ target: "draft-2020-12" });
+		if (require_type_checks.isUntypedInput(schema)) return convertUntypedInputToJsonSchema(schema);
+		if (require_type_checks.isUntypedSchema(schema)) return convertUntypedSchemaToJsonSchema(schema);
+		return schema;
 	}
 }
-/**
-* Extracts a schema definition from a given input object, which can be a Zod schema, a Standard JSON Schema, a JSON Schema object, or a reflected Deepkit Type object. The function checks the type of the input and attempts to extract the corresponding schema based on its variant. If the input is a Zod schema, it extracts the JSON Schema using the `extractJsonSchema` function. If the input is a Standard JSON Schema, it retrieves the JSON Schema targeting draft-07. If the input is already a JSON Schema object, it uses it directly. If the input is a reflected Deepkit Type object, it extracts the schema using the `extractReflection` function. The function returns a `Schema` containing the extracted schema and its variant if successful; otherwise, it throws an error.
-*
-* @param input - The input object to extract the schema definition from.
-* @returns A `Schema` containing the extracted schema and its variant if successful.
-* @throws An error if the input does not contain a valid schema definition.
-*/
 function extractResolvedVariant(input) {
 	if ((0, _stryke_type_checks_is_set_object.isSetObject)(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 (require_type_checks.isJsonSchema(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 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 (resolvedVariant === "zod3" || resolvedVariant === "json-schema" || resolvedVariant === "standard-schema" || resolvedVariant === "untyped") schema = extractJsonSchema(input);
+	else if (resolvedVariant === "reflection") schema = extractReflection(input);
 	if (schema) return schema;
-	throw new Error(`Failed to extract a valid schema from the provided input. The input must be a Zod schema, a Standard JSON Schema, a JSON Schema object, a JTD schema, an untyped schema, or a reflected Deepkit Type object.`);
+	throw new Error(`Failed to extract a valid schema from the provided input. The input must be a Zod schema, a Standard JSON Schema, a JSON Schema object, an untyped schema, or a reflected Deepkit Type object.`);
 }
-/**
-* Extracts a schema definition from a given input object, which can be a Zod schema, a Standard JSON Schema, a JSON Schema object, a JTD schema, an untyped schema, or a reflected Deepkit Type object. The function checks the type of the input and attempts to extract the corresponding schema based on its variant. If the input is a Zod schema, it extracts the JSON Schema using the `extractJsonSchema` function. If the input is a Standard JSON Schema, it retrieves the JSON Schema targeting draft-07. If the input is already a JSON Schema object, it uses it directly. If the input is a reflected Deepkit Type object, it extracts the schema using the `extractReflection` function. The function returns a `Schema` containing the extracted schema and its variant if successful; otherwise, it throws an error.
-*
-* @param variant - The variant of the schema definition to extract.
-* @param input - The input object to extract the schema definition from.
-* @returns A `Schema` containing the extracted schema and its variant if successful.
-* @throws An error if the input does not contain a valid schema definition.
-*/
 function extractSource(variant, input) {
 	if (variant === "zod3") return {
 		hash: extractHash(variant, input),
@@ -162,40 +191,41 @@ function extractSource(variant, input) {
 		variant: "reflection",
 		schema: input
 	};
-	else if (variant === "jtd-schema") return {
-		hash: extractHash(variant, input),
-		variant: "jtd-schema",
-		schema: input
-	};
-	throw new Error(`Failed to extract source information from the provided input. The input must be a Zod schema, a Standard JSON Schema, a JSON Schema object, a JTD schema, an untyped schema, or a reflected Deepkit Type object.`);
+	throw new Error(`Failed to extract source information from the provided input. The input must be a Zod schema, a Standard JSON Schema, a JSON Schema object, an untyped schema, or a reflected Deepkit Type object.`);
 }
 /**
-* Resolves the provided entry points to their corresponding type definitions. The function accepts an array of entry points, which can be strings (file paths) or type definition objects. It processes each entry point, resolving file paths and glob patterns to find matching files. For each resolved file, it creates a type definition object and resolves it using the `resolveInput` function. The function returns an array of resolved entry type definitions.
+* Extracts a JSON Schema from a given schema definition input, which can be a Zod schema, a Standard JSON Schema, a JSON Schema object, an untyped schema, or a reflected Deepkit Type object. If the input is a type definition reference (e.g. a file path with an export), it will be resolved and bundled using ESBuild to obtain the actual schema definition before extraction.
 *
 * @example
 * ```ts
 * // Resolve a schema definition from a file path
-* const schema1 = await extractSchema(context, "./schemas.ts#MySchema");
+* const schema1 = await extract(context, "./schemas.ts#MySchema");
 * // Resolve a schema definition from a JSON Schema object
-* const schema2 = await extractSchema(context, schemaObject);
+* const schema2 = await extract(context, schemaObject);
 * // Resolve a schema definition from a Zod schema
-* const schema3 = await extractSchema(context, zodSchema);
+* const schema3 = await extract(context, zodSchema);
 * // Resolve a schema definition from a reflected Deepkit Type object
-* const schema4 = await extractSchema(context, reflectionType);
+* const schema4 = await extract(context, reflectionType);
 * ```
 *
-* @param context - The plugin context used for resolving the schema definition input.
-* @param input - The schema definition input to extract the JSON Schema from. This can be a Zod schema, a Standard JSON Schema, a JSON Schema object, or a TypeScript type definition.
-* @param options - Optional overrides for the ESBuild configuration used during resolution.
-* @returns A promise that resolves to a {@link ExtractedSchema} containing the extracted JSON Schema and its variant, or the bytecode if JSON Schema extraction is not possible.
+* @see https://github.com/colinhacks/zod
+* @see https://standardschema.dev/json-schema#what-schema-libraries-support-this-spec
+* @see https://json-schema.org/
+* @see https://ajv.js.org/json-type-definition.html
+* @see https://deepkit.io/en/documentation/runtime-types/reflection
+*
+* @param context - The context object providing access to the file system and cache path.
+* @param input - The schema definition input to extract, which can be a Zod schema, a Standard JSON Schema, a JSON Schema object, an untyped schema, or a reflected Deepkit Type object. If the input is a string or a type definition reference, it will be resolved and bundled to obtain the actual schema definition before extraction.
+* @param options - Optional overrides for the ESBuild configuration used during extraction. This can include custom plugins, loaders, or other build options to control how the schema definition is resolved and bundled when the input is a type definition reference.
+* @returns A promise that resolves to the extracted and normalized schema as a JSON Schema object. The function will attempt to extract a valid JSON Schema from the provided input, and if successful, it will return the schema. If the extraction process fails or if the input is not a valid schema definition, it will throw an error indicating the failure.
 */
 async function extractSchema(context, input, options = {}) {
 	if (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",
+			hash: extractHash("json-schema", input.schema),
+			variant: "json-schema",
 			schema: input.schema
 		}
 	};
@@ -203,20 +233,19 @@ async function extractSchema(context, input, options = {}) {
 	const variant = extractVariant(input);
 	const hash = extractHash(variant, 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, {
+		const resolved = await require_resolve.resolve(context, input, (0, defu.default)(options, { plugins: [(0, _powerlines_deepkit_rolldown_plugin.rolldownPlugin)(context, {
 			reflection: "default",
 			level: "all"
 		})] }));
 		source = extractSource(extractResolvedVariant(resolved), resolved);
 	} else if ([
 		"json-schema",
-		"jtd-schema",
 		"standard-schema",
 		"zod3",
 		"untyped",
 		"reflection"
 	].includes(variant)) source = extractSource(variant, input);
-	else throw new Error(`Invalid schema definition input "${variant}". The variant must be one of "type-definition", "json-schema", "jtd-schema", "standard-schema", "zod3", "untyped", or "reflection".`);
+	else throw new Error(`Invalid schema definition input "${variant}". The variant must be one of "type-definition", "json-schema", "standard-schema", "zod3", "untyped", or "reflection".`);
 	return {
 		variant,
 		source,
@@ -225,7 +254,7 @@ async function extractSchema(context, input, options = {}) {
 	};
 }
 /**
-* Resolves the provided entry points to their corresponding type definitions. The function accepts an array of entry points, which can be strings (file paths) or type definition objects. It processes each entry point, resolving file paths and glob patterns to find matching files. For each resolved file, it creates a type definition object and resolves it using the `resolveInput` function. The function returns an array of resolved entry type definitions.
+* Extracts a JSON Schema from a given schema definition input, which can be a Zod schema, a Standard JSON Schema, a JSON Schema object, an untyped schema, or a reflected Deepkit Type object. If the input is a type definition reference (e.g. a file path with an export), it will be resolved and bundled using ESBuild to obtain the actual schema definition before extraction.
 *
 * @example
 * ```ts
@@ -247,10 +276,11 @@ async function extractSchema(context, input, options = {}) {
 * @see https://github.com/unjs/untyped
 * @see https://www.typescriptlang.org/docs/handbook/2/types-from-types.html
 *
-* @param context - The {@link Context | context} used for resolving the {@link Schema | schema} definition input.
-* @param input - The input object or string to extract the {@link Schema | schema} from. This can be {@link TypeDefinitionReference | a string that references a Typescript module}, a [Zod v3 schema](https://github.com/colinhacks/zod), any type that adheres to [the Standard JSON Schema specification](https://standardschema.dev/json-schema#what-schema-libraries-support-this-spec), a [JSON Schema object](https://json-schema.org/), a [JTD schema object](https://ajv.js.org/json-type-definition.html), an [untyped schema](https://github.com/unjs/untyped), or a [TypeScript type reflection](https://deepkit.io/en/documentation/runtime-types/reflection).
-* @param options - Optional overrides for the [ESBuild configuration](https://esbuild.github.io/api/#general-options) used during resolution.
-* @returns A promise that resolves to a {@link Schema | schema} object parsed from the input.
+* @param context - The context object providing access to the file system and cache path.
+* @param input - The schema definition input to extract, which can be a Zod schema, a Standard JSON Schema, a JSON Schema object, an untyped schema, or a reflected Deepkit Type object.
+* @param options - Optional overrides for the ESBuild configuration used during extraction.
+* @returns A promise that resolves to the extracted and normalized schema as a JSON Schema object.
+* @throws Will throw an error if the input is not a valid schema definition or if the extraction process fails to produce a valid schema.
 */
 async function extract(context, input, options = {}) {
 	if (require_type_checks.isExtractedSchema(input) || require_type_checks.isSchema(input)) return input;
@@ -267,7 +297,7 @@ async function extract(context, input, options = {}) {
 		};
 	}
 	result ??= await extractSchema(context, input, options);
-	if (!result?.schema) throw new Error(`Failed to extract a valid schema from the provided input. The input must be a Zod schema, a Standard JSON Schema, a JSON Schema object, a JTD schema, an untyped schema, or a reflected Deepkit Type object.`);
+	if (!result?.schema) throw new Error(`Failed to extract a valid schema from the provided input. The input must be a Zod schema, a Standard JSON Schema, a JSON Schema object, an untyped schema, or a reflected Deepkit Type object.`);
 	if (context.config.skipCache !== true) await require_persistence.writeSchema(context, result);
 	return result;
 }