@powerlines/schema 0.11.1 → 0.11.3

package/dist/extract.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"extract.mjs","names":["isSetObject"],"sources":["../src/extract.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 { PluginContext } from \"@powerlines/core\";\nimport { isTypeDefinition } from \"@powerlines/core\";\nimport { esbuildPlugin } from \"@powerlines/deepkit/esbuild-plugin\";\nimport { isType, Type } from \"@powerlines/deepkit/vendor/type\";\nimport type { JsonSchema7Type } from \"@stryke/json\";\nimport { isJsonSchema7ObjectType, isStandardJsonSchema } from \"@stryke/json\";\nimport { isSetString } from \"@stryke/type-checks\";\nimport { isSetObject } from \"@stryke/type-checks/is-set-object\";\nimport { extractJsonSchema7, isZod3Type } from \"@stryke/zod\";\nimport defu from \"defu\";\nimport type { BuildOptions } from \"esbuild\";\nimport { isSchemaDefinition } from \"./is-schema-definition\";\nimport { reflectionToJsonSchema } from \"./reflection\";\nimport { resolve } from \"./resolve\";\nimport {\n  SchemaDefinition,\n  SchemaDefinitionInput,\n  SchemaDefinitionParameter\n} from \"./types\";\n\n/**\n * Converts a reflected Deepkit {@link @powerlines/deepkit/vendor/type#Type} into a JSON Schema (draft-07) representation.\n *\n * @remarks\n * This function delegates to an internal recursive walker that handles the full set of Deepkit reflection kinds.\n *\n * @param reflection - The reflected Deepkit Type to convert.\n * @returns A JSON Schema (draft-07) fragment representing the type, or `undefined` when no schema could be produced.\n */\nexport function extractReflection(\n  reflection: Type\n): JsonSchema7Type | undefined {\n  if (!isType(reflection)) {\n    return undefined;\n  }\n\n  return reflectionToJsonSchema(reflection);\n}\n\n/**\n * Extracts a JSON Schema object from a given schema definition, if possible.\n *\n * @remarks\n * 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.\n *\n * @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.\n * @returns The extracted JSON Schema (draft-07) object if successful, otherwise undefined.\n */\nexport function extractJsonSchema(\n  schema: unknown\n): JsonSchema7Type | undefined {\n  if (\n    isSetObject(schema) &&\n    (isZod3Type(schema) ||\n      isStandardJsonSchema(schema) ||\n      isJsonSchema7ObjectType(schema))\n  ) {\n    let jsonSchema: JsonSchema7Type;\n    if (isZod3Type(schema)) {\n      jsonSchema = extractJsonSchema7(schema);\n    } else if (isStandardJsonSchema(schema)) {\n      jsonSchema = schema[\"~standard\"].jsonSchema.input({\n        target: \"draft-07\"\n      });\n    } else {\n      jsonSchema = schema;\n    }\n\n    if (isJsonSchema7ObjectType(jsonSchema)) {\n      return jsonSchema;\n    }\n  }\n\n  return undefined;\n}\n\n/**\n * 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.\n *\n * @param input - The input object to extract the schema definition from.\n * @returns A `SchemaDefinition` containing the extracted schema and its variant if successful.\n * @throws An error if the input does not contain a valid schema definition.\n */\nexport function extractSchema(input: SchemaDefinitionInput): SchemaDefinition {\n  if (isSetObject(input)) {\n    if (isZod3Type(input)) {\n      const schema = extractJsonSchema(input);\n      if (schema) {\n        return {\n          schema,\n          variant: \"zod3\",\n          input\n        };\n      }\n    } else if (isStandardJsonSchema(input)) {\n      const schema = extractJsonSchema(input);\n      if (schema) {\n        return {\n          schema,\n          variant: \"standard-schema\",\n          input\n        };\n      }\n    } else if (isJsonSchema7ObjectType(input)) {\n      const schema = extractJsonSchema(input);\n      if (schema) {\n        return {\n          schema,\n          variant: \"json-schema\",\n          input\n        };\n      }\n    } else if (isType(input)) {\n      const schema = extractReflection(input);\n      if (schema) {\n        return {\n          schema,\n          variant: \"reflection\",\n          input\n        };\n      }\n    }\n  }\n\n  throw new Error(\n    `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.`\n  );\n}\n\n/**\n * 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.\n *\n * @example\n * ```ts\n * const schema = await extract(context, \"./schemas/*.ts\");\n * ```\n *\n * @param context - The plugin context used for resolving the schema definition input.\n * @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.\n * @param options - Optional overrides for the ESBuild configuration used during resolution.\n * @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.\n */\nexport async function extract<TContext extends PluginContext = PluginContext>(\n  context: TContext,\n  input: SchemaDefinitionParameter,\n  options: Partial<BuildOptions> = {}\n): Promise<SchemaDefinition> {\n  if (isSchemaDefinition(input)) {\n    return input;\n  }\n\n  let inputObject = input as SchemaDefinitionInput;\n  if (isSetString(input) || isTypeDefinition(input)) {\n    inputObject = await resolve<SchemaDefinitionInput>(\n      context,\n      input,\n      defu(options, {\n        plugins: [\n          esbuildPlugin(context, {\n            reflection: \"default\",\n            level: \"all\"\n          })\n        ]\n      })\n    );\n  }\n\n  return extractSchema(inputObject);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AA+CA,SAAgB,kBACd,YAC6B;AAC7B,KAAI,CAAC,OAAO,WAAW,CACrB;AAGF,QAAO,uBAAuB,WAAW;;;;;;;;;;;AAY3C,SAAgB,kBACd,QAC6B;AAC7B,KACEA,cAAY,OAAO,KAClB,WAAW,OAAO,IACjB,qBAAqB,OAAO,IAC5B,wBAAwB,OAAO,GACjC;EACA,IAAI;AACJ,MAAI,WAAW,OAAO,CACpB,cAAa,mBAAmB,OAAO;WAC9B,qBAAqB,OAAO,CACrC,cAAa,OAAO,aAAa,WAAW,MAAM,EAChD,QAAQ,YACT,CAAC;MAEF,cAAa;AAGf,MAAI,wBAAwB,WAAW,CACrC,QAAO;;;;;;;;;;AAcb,SAAgB,cAAc,OAAgD;AAC5E,KAAIA,cAAY,MAAM,EACpB;MAAI,WAAW,MAAM,EAAE;GACrB,MAAM,SAAS,kBAAkB,MAAM;AACvC,OAAI,OACF,QAAO;IACL;IACA,SAAS;IACT;IACD;aAEM,qBAAqB,MAAM,EAAE;GACtC,MAAM,SAAS,kBAAkB,MAAM;AACvC,OAAI,OACF,QAAO;IACL;IACA,SAAS;IACT;IACD;aAEM,wBAAwB,MAAM,EAAE;GACzC,MAAM,SAAS,kBAAkB,MAAM;AACvC,OAAI,OACF,QAAO;IACL;IACA,SAAS;IACT;IACD;aAEM,OAAO,MAAM,EAAE;GACxB,MAAM,SAAS,kBAAkB,MAAM;AACvC,OAAI,OACF,QAAO;IACL;IACA,SAAS;IACT;IACD;;;AAKP,OAAM,IAAI,MACR,8KACD;;;;;;;;;;;;;;;AAgBH,eAAsB,QACpB,SACA,OACA,UAAiC,EAAE,EACR;AAC3B,KAAI,mBAAmB,MAAM,CAC3B,QAAO;CAGT,IAAI,cAAc;AAClB,KAAI,YAAY,MAAM,IAAI,iBAAiB,MAAM,CAC/C,eAAc,MAAM,QAClB,SACA,OACA,KAAK,SAAS,EACZ,SAAS,CACP,cAAc,SAAS;EACrB,YAAY;EACZ,OAAO;EACR,CAAC,CACH,EACF,CAAC,CACH;AAGH,QAAO,cAAc,YAAY"}
+{"version":3,"file":"extract.mjs","names":["isSetObject","extractJsonSchemaZod"],"sources":["../src/extract.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 { Context } from \"@powerlines/core\";\nimport { isTypeDefinition } from \"@powerlines/core\";\nimport { esbuildPlugin } from \"@powerlines/deepkit/esbuild-plugin\";\nimport { isType, stringifyType, Type } from \"@powerlines/deepkit/vendor/type\";\nimport { StandardJSONSchemaV1 } from \"@standard-schema/spec\";\nimport { murmurhash } from \"@stryke/hash\";\nimport {\n  isJsonSchemaObjectType,\n  isStandardJsonSchema,\n  JsonSchemaType\n} from \"@stryke/json\";\nimport { isSetString } from \"@stryke/type-checks\";\nimport { isSetObject } from \"@stryke/type-checks/is-set-object\";\nimport {\n  extractJsonSchema as extractJsonSchemaZod,\n  isZod3Type\n} from \"@stryke/zod\";\nimport defu from \"defu\";\nimport type { BuildOptions } from \"esbuild\";\nimport * as z3 from \"zod/v3\";\nimport { jsonSchemaToJtd } from \"./jtd\";\nimport { reflectionToJsonSchema } from \"./reflection\";\nimport { resolve } from \"./resolve\";\nimport {\n  isExtractedSchema,\n  isJTDSchema,\n  isSchema,\n  isUntypedInput,\n  isUntypedSchema\n} from \"./type-checks\";\nimport {\n  ExtractedSchema,\n  JsonSchemaLike,\n  JTDSchemaType,\n  Schema,\n  SchemaInput,\n  SchemaInputVariant,\n  SchemaMetadata,\n  SchemaSource,\n  SchemaSourceInput,\n  SchemaSourceVariant,\n  TypeDefinitionReference,\n  UntypedInputObject,\n  UntypedSchema\n} from \"./types\";\n\n/**\n * 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.\n */\nexport function extractHash(\n  variant: SchemaInputVariant,\n  input: SchemaInput\n): string {\n  if (isSetString(input)) {\n    return murmurhash({ variant, input });\n  } else if (isSetObject(input)) {\n    if (isZod3Type(input)) {\n      return murmurhash({ variant, input: input._def });\n    } else if (isStandardJsonSchema(input)) {\n      return murmurhash({ variant, input: input[\"~standard\"] });\n    } else if (isJsonSchemaObjectType(input)) {\n      return murmurhash({ variant, input });\n    } else if (isType(input)) {\n      return murmurhash({ variant, input: stringifyType(input) });\n    }\n  }\n\n  throw new Error(\n    `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.`\n  );\n}\n\n/**\n * Converts a reflected Deepkit {@link @powerlines/deepkit/vendor/type#Type} into a JSON Schema (draft-07) representation.\n *\n * @remarks\n * This function delegates to an internal recursive walker that handles the full set of Deepkit reflection kinds.\n *\n * @param reflection - The reflected Deepkit Type to convert.\n * @returns A JSON Schema (draft-07) fragment representing the type, or `undefined` when no schema could be produced.\n */\nexport function extractReflection<\n  TMetadata extends Partial<SchemaMetadata> = Partial<SchemaMetadata>\n>(reflection: Type): JTDSchemaType<TMetadata> | undefined {\n  if (!isType(reflection)) {\n    return undefined;\n  }\n\n  return reflectionToJsonSchema<TMetadata>(reflection);\n}\n\n/**\n * Extracts a JSON Type Definition (RFC 8927) schema from a given schema definition, if possible.\n *\n * @remarks\n * 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.\n *\n * @param schema - The schema definition to extract from. This can be a Zod schema, a Standard JSON Schema, or a JSON Schema object.\n * @returns The extracted JTD schema if successful, otherwise undefined.\n */\nexport function extractJsonSchema<\n  TMetadata extends Partial<SchemaMetadata> = Partial<SchemaMetadata>\n>(schema: unknown): JTDSchemaType<TMetadata> | undefined {\n  if (\n    isSetObject(schema) &&\n    (isZod3Type(schema) ||\n      isStandardJsonSchema(schema) ||\n      isJsonSchemaObjectType(schema) ||\n      isUntypedInput(schema) ||\n      isUntypedSchema(schema))\n  ) {\n    let jsonSchema: unknown;\n    if (isZod3Type(schema)) {\n      jsonSchema = extractJsonSchemaZod(schema);\n    } else if (isStandardJsonSchema(schema)) {\n      jsonSchema = schema[\"~standard\"].jsonSchema.input({\n        target: \"draft-2020-12\"\n      });\n    } else if (isUntypedInput(schema)) {\n      jsonSchema = schema.$schema;\n    } else {\n      jsonSchema = schema;\n    }\n\n    const jtd = jsonSchemaToJtd<TMetadata>(jsonSchema as JsonSchemaLike);\n    if (jtd) {\n      return jtd;\n    }\n  }\n\n  return undefined;\n}\n\n/**\n * 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.\n *\n * @param input - The input object to extract the schema definition from.\n * @returns A `Schema` containing the extracted schema and its variant if successful.\n * @throws An error if the input does not contain a valid schema definition.\n */\nexport function extractResolvedVariant(\n  input: SchemaSourceInput\n): SchemaSourceVariant {\n  if (isSetObject(input)) {\n    if (isZod3Type(input)) {\n      return \"zod3\";\n    } else if (isStandardJsonSchema(input)) {\n      return \"standard-schema\";\n    } else if (isJTDSchema(input)) {\n      return \"jtd-schema\";\n    } else if (isJsonSchemaObjectType(input)) {\n      return \"json-schema\";\n    } else if (isType(input)) {\n      return \"reflection\";\n    } else if (isUntypedInput(input) || isUntypedSchema(input)) {\n      return \"untyped\";\n    }\n  }\n\n  throw new Error(\n    `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.`\n  );\n}\n\n/**\n * 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.\n *\n * @param input - The input object to extract the schema definition from.\n * @returns A `Schema` containing the extracted schema and its variant if successful.\n * @throws An error if the input does not contain a valid schema definition.\n */\nexport function extractVariant(input: SchemaInput): SchemaInputVariant {\n  if (isSetString(input) || isTypeDefinition(input)) {\n    return \"type-definition\";\n  }\n\n  return extractResolvedVariant(input as SchemaSourceInput);\n}\n\n/**\n * 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.\n *\n * @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.\n * @param variant - The variant of the schema definition to extract.\n * @returns The extracted JSON Schema if successful.\n * @throws An error if the input does not contain a valid schema definition.\n */\nexport async function extractSchemaSchema<\n  TMetadata extends Partial<SchemaMetadata> = Partial<SchemaMetadata>\n>(\n  input: SchemaSourceInput,\n  variant?: SchemaInputVariant\n): Promise<JTDSchemaType<TMetadata>> {\n  if (isExtractedSchema<TMetadata>(input)) {\n    return input.schema;\n  }\n\n  const resolvedVariant = variant ?? extractResolvedVariant(input);\n\n  let schema: JTDSchemaType<TMetadata> | undefined;\n  if (\n    resolvedVariant === \"zod3\" ||\n    resolvedVariant === \"json-schema\" ||\n    resolvedVariant === \"standard-schema\" ||\n    resolvedVariant === \"untyped\"\n  ) {\n    const jsonSchema = extractJsonSchema<TMetadata>(input);\n    if (jsonSchema) {\n      schema = jsonSchemaToJtd<TMetadata>(jsonSchema);\n    }\n  } else if (resolvedVariant === \"reflection\") {\n    schema = extractReflection<TMetadata>(input as Type);\n  } else if (resolvedVariant === \"jtd-schema\") {\n    schema = input as JTDSchemaType<TMetadata>;\n  }\n\n  if (schema) {\n    return schema;\n  }\n\n  throw new Error(\n    `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.`\n  );\n}\n\n/**\n * 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.\n *\n * @param variant - The variant of the schema definition to extract.\n * @param input - The input object to extract the schema definition from.\n * @returns A `Schema` containing the extracted schema and its variant if successful.\n * @throws An error if the input does not contain a valid schema definition.\n */\nexport function extractSource<\n  TMetadata extends Partial<SchemaMetadata> = Partial<SchemaMetadata>\n>(variant: SchemaSourceVariant, input: SchemaSourceInput): SchemaSource {\n  if (variant === \"zod3\") {\n    return {\n      hash: extractHash(variant, input),\n      variant: \"zod3\",\n      schema: input as z3.ZodTypeAny\n    };\n  } else if (variant === \"untyped\") {\n    return {\n      hash: extractHash(variant, input),\n      variant: \"untyped\",\n      schema: input as UntypedInputObject | UntypedSchema\n    };\n  } else if (variant === \"standard-schema\") {\n    return {\n      hash: extractHash(variant, input),\n      variant: \"standard-schema\",\n      schema: input as StandardJSONSchemaV1\n    };\n  } else if (variant === \"json-schema\") {\n    return {\n      hash: extractHash(variant, input),\n      variant: \"json-schema\",\n      schema: input as JsonSchemaType\n    };\n  } else if (variant === \"reflection\") {\n    return {\n      hash: extractHash(variant, input),\n      variant: \"reflection\",\n      schema: input as Type\n    };\n  } else if (variant === \"jtd-schema\") {\n    return {\n      hash: extractHash(variant, input),\n      variant: \"jtd-schema\",\n      schema: input as JTDSchemaType<TMetadata>\n    };\n  }\n\n  throw new Error(\n    `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.`\n  );\n}\n\n/**\n * 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.\n *\n * @example\n * ```ts\n * // Resolve a schema definition from a file path\n * const schema1 = await extractSchema(context, \"./schemas.ts#MySchema\");\n * // Resolve a schema definition from a JSON Schema object\n * const schema2 = await extractSchema(context, schemaObject);\n * // Resolve a schema definition from a Zod schema\n * const schema3 = await extractSchema(context, zodSchema);\n * // Resolve a schema definition from a reflected Deepkit Type object\n * const schema4 = await extractSchema(context, reflectionType);\n * ```\n *\n * @param context - The plugin context used for resolving the schema definition input.\n * @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.\n * @param options - Optional overrides for the ESBuild configuration used during resolution.\n * @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.\n */\nexport async function extractSchema<\n  TMetadata extends Partial<SchemaMetadata> = Partial<SchemaMetadata>,\n  TContext extends Context = Context\n>(\n  context: TContext,\n  input: SchemaInput,\n  options: Partial<BuildOptions> = {}\n): Promise<ExtractedSchema<TMetadata>> {\n  if (isExtractedSchema<TMetadata>(input)) {\n    return input;\n  }\n\n  if (isSchema<TMetadata>(input)) {\n    return {\n      ...input,\n      source: {\n        hash: extractHash(\"jtd-schema\", input.schema),\n        variant: \"jtd-schema\",\n        schema: input.schema\n      }\n    };\n  }\n\n  let source: SchemaSource;\n\n  const variant = extractVariant(input);\n  if (variant === \"type-definition\") {\n    const resolved = await resolve<SchemaSourceInput>(\n      context,\n      input as TypeDefinitionReference,\n      defu(options, {\n        plugins: [\n          esbuildPlugin(context, {\n            reflection: \"default\",\n            level: \"all\"\n          })\n        ]\n      })\n    );\n\n    source = extractSource(extractResolvedVariant(resolved), resolved);\n  } else if (\n    [\n      \"json-schema\",\n      \"jtd-schema\",\n      \"standard-schema\",\n      \"zod3\",\n      \"untyped\",\n      \"reflection\"\n    ].includes(variant)\n  ) {\n    source = extractSource(variant, input as SchemaSourceInput);\n  } else {\n    throw new Error(\n      `Invalid schema definition input \"${\n        variant\n      }\". The variant must be one of \"type-definition\", \"json-schema\", \"jtd-schema\", \"standard-schema\", \"zod3\", \"untyped\", or \"reflection\".`\n    );\n  }\n\n  return {\n    variant,\n    source,\n    schema: await extractSchemaSchema<TMetadata>(source.schema, source.variant),\n    hash: extractHash(variant, input)\n  };\n}\n\n/**\n * 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.\n *\n * @example\n * ```ts\n * // Resolve a schema definition from a file path\n * const schema1 = await extract(context, \"./schemas.ts#MySchema\");\n * // Resolve a schema definition from a JSON Schema object\n * const schema2 = await extract(context, schemaObject);\n * // Resolve a schema definition from a Zod schema\n * const schema3 = await extract(context, zodSchema);\n * // Resolve a schema definition from a reflected Deepkit Type object\n * const schema4 = await extract(context, reflectionType);\n * ```\n *\n * @see https://github.com/colinhacks/zod\n * @see https://standardschema.dev/json-schema#what-schema-libraries-support-this-spec\n * @see https://json-schema.org/\n * @see https://ajv.js.org/json-type-definition.html\n * @see https://deepkit.io/en/documentation/runtime-types/reflection\n * @see https://github.com/unjs/untyped\n * @see https://www.typescriptlang.org/docs/handbook/2/types-from-types.html\n *\n * @param context - The {@link Context | context} used for resolving the {@link Schema | schema} definition input.\n * @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).\n * @param options - Optional overrides for the [ESBuild configuration](https://esbuild.github.io/api/#general-options) used during resolution.\n * @returns A promise that resolves to a {@link Schema | schema} object parsed from the input.\n */\nexport async function extract<\n  TMetadata extends Partial<SchemaMetadata> = Partial<SchemaMetadata>,\n  TContext extends Context = Context\n>(\n  context: TContext,\n  input: SchemaInput,\n  options: Partial<BuildOptions> = {}\n): Promise<Schema<TMetadata>> {\n  const result = await extractSchema<TMetadata>(context, input, options);\n\n  return result;\n}\n"],"mappings":"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"}

package/dist/index.cjs

@@ -1,17 +1,29 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_bundle = require('./bundle.cjs');
-const require_is_schema_definition = require('./is-schema-definition.cjs');
+const require_codegen = require('./codegen.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');
 const require_extract = require('./extract.cjs');
 
 exports.bundle = require_bundle.bundle;
 exports.extract = require_extract.extract;
+exports.extractHash = require_extract.extractHash;
 exports.extractJsonSchema = require_extract.extractJsonSchema;
 exports.extractReflection = require_extract.extractReflection;
+exports.extractResolvedVariant = require_extract.extractResolvedVariant;
 exports.extractSchema = require_extract.extractSchema;
-exports.isSchemaDefinition = require_is_schema_definition.isSchemaDefinition;
-exports.objectReflectionToJsonSchema = require_reflection.objectReflectionToJsonSchema;
+exports.extractSchemaSchema = require_extract.extractSchemaSchema;
+exports.extractSource = require_extract.extractSource;
+exports.extractVariant = require_extract.extractVariant;
+exports.generateCode = require_codegen.generateCode;
+exports.isExtractedSchema = require_type_checks.isExtractedSchema;
+exports.isJTDSchema = require_type_checks.isJTDSchema;
+exports.isSchema = require_type_checks.isSchema;
+exports.isUntypedInput = require_type_checks.isUntypedInput;
+exports.isUntypedSchema = require_type_checks.isUntypedSchema;
+exports.jsonSchemaToJtd = require_jtd.jsonSchemaToJtd;
 exports.reflectionToJsonSchema = require_reflection.reflectionToJsonSchema;
 exports.resolve = require_resolve.resolve;
 exports.resolveModule = require_resolve.resolveModule;

package/dist/index.d.cts

@@ -1,7 +1,9 @@
 import { BundleOptions, bundle } from "./bundle.cjs";
-import { SchemaDefinition, SchemaDefinitionBase, SchemaDefinitionInput, SchemaDefinitionJsonSchema, SchemaDefinitionParameter, SchemaDefinitionReflection, SchemaDefinitionStandardSchema, SchemaDefinitionVariant, SchemaDefinitionZod3 } from "./types.cjs";
-import { extract, extractJsonSchema, extractReflection, extractSchema } from "./extract.cjs";
-import { isSchemaDefinition } from "./is-schema-definition.cjs";
-import { objectReflectionToJsonSchema, reflectionToJsonSchema } from "./reflection.cjs";
+import { generateCode } from "./codegen.cjs";
+import { BaseSchemaSource, ExtractedSchema, JTDNumberType, JTDSchemaSchemaSource, JTDSchemaType, JTDStringType, JTDType, JsonSchemaLike, JsonSchemaSchemaSource, ReflectionSchemaSource, Schema, SchemaInput, SchemaInputVariant, SchemaMetadata, SchemaSource, SchemaSourceInput, SchemaSourceVariant, StandardSchemaSchemaSource, TypeDefinitionReference, UntypedInputObject, UntypedSchema, UntypedSchemaSource, Zod3SchemaSource } from "./types.cjs";
+import { extract, extractHash, extractJsonSchema, extractReflection, extractResolvedVariant, extractSchema, extractSchemaSchema, extractSource, extractVariant } from "./extract.cjs";
+import { jsonSchemaToJtd } from "./jtd.cjs";
+import { reflectionToJsonSchema } from "./reflection.cjs";
 import { resolve, resolveModule, resolveReflection } from "./resolve.cjs";
-export { BundleOptions, SchemaDefinition, SchemaDefinitionBase, SchemaDefinitionInput, SchemaDefinitionJsonSchema, SchemaDefinitionParameter, SchemaDefinitionReflection, SchemaDefinitionStandardSchema, SchemaDefinitionVariant, SchemaDefinitionZod3, bundle, extract, extractJsonSchema, extractReflection, extractSchema, isSchemaDefinition, objectReflectionToJsonSchema, reflectionToJsonSchema, resolve, resolveModule, resolveReflection };
+import { isExtractedSchema, isJTDSchema, isSchema, isUntypedInput, isUntypedSchema } from "./type-checks.cjs";
+export { BaseSchemaSource, BundleOptions, ExtractedSchema, JTDNumberType, JTDSchemaSchemaSource, JTDSchemaType, JTDStringType, JTDType, JsonSchemaLike, JsonSchemaSchemaSource, ReflectionSchemaSource, Schema, SchemaInput, SchemaInputVariant, SchemaMetadata, SchemaSource, SchemaSourceInput, SchemaSourceVariant, StandardSchemaSchemaSource, TypeDefinitionReference, UntypedInputObject, UntypedSchema, UntypedSchemaSource, Zod3SchemaSource, bundle, extract, extractHash, extractJsonSchema, extractReflection, extractResolvedVariant, extractSchema, extractSchemaSchema, extractSource, extractVariant, generateCode, isExtractedSchema, isJTDSchema, isSchema, isUntypedInput, isUntypedSchema, jsonSchemaToJtd, reflectionToJsonSchema, resolve, resolveModule, resolveReflection };

package/dist/index.d.mts

@@ -1,7 +1,9 @@
 import { BundleOptions, bundle } from "./bundle.mjs";
-import { SchemaDefinition, SchemaDefinitionBase, SchemaDefinitionInput, SchemaDefinitionJsonSchema, SchemaDefinitionParameter, SchemaDefinitionReflection, SchemaDefinitionStandardSchema, SchemaDefinitionVariant, SchemaDefinitionZod3 } from "./types.mjs";
-import { extract, extractJsonSchema, extractReflection, extractSchema } from "./extract.mjs";
-import { isSchemaDefinition } from "./is-schema-definition.mjs";
-import { objectReflectionToJsonSchema, reflectionToJsonSchema } from "./reflection.mjs";
+import { generateCode } from "./codegen.mjs";
+import { BaseSchemaSource, ExtractedSchema, JTDNumberType, JTDSchemaSchemaSource, JTDSchemaType, JTDStringType, JTDType, JsonSchemaLike, JsonSchemaSchemaSource, ReflectionSchemaSource, Schema, SchemaInput, SchemaInputVariant, SchemaMetadata, SchemaSource, SchemaSourceInput, SchemaSourceVariant, StandardSchemaSchemaSource, TypeDefinitionReference, UntypedInputObject, UntypedSchema, UntypedSchemaSource, Zod3SchemaSource } from "./types.mjs";
+import { extract, extractHash, extractJsonSchema, extractReflection, extractResolvedVariant, extractSchema, extractSchemaSchema, extractSource, extractVariant } from "./extract.mjs";
+import { jsonSchemaToJtd } from "./jtd.mjs";
+import { reflectionToJsonSchema } from "./reflection.mjs";
 import { resolve, resolveModule, resolveReflection } from "./resolve.mjs";
-export { BundleOptions, SchemaDefinition, SchemaDefinitionBase, SchemaDefinitionInput, SchemaDefinitionJsonSchema, SchemaDefinitionParameter, SchemaDefinitionReflection, SchemaDefinitionStandardSchema, SchemaDefinitionVariant, SchemaDefinitionZod3, bundle, extract, extractJsonSchema, extractReflection, extractSchema, isSchemaDefinition, objectReflectionToJsonSchema, reflectionToJsonSchema, resolve, resolveModule, resolveReflection };
+import { isExtractedSchema, isJTDSchema, isSchema, isUntypedInput, isUntypedSchema } from "./type-checks.mjs";
+export { BaseSchemaSource, BundleOptions, ExtractedSchema, JTDNumberType, JTDSchemaSchemaSource, JTDSchemaType, JTDStringType, JTDType, JsonSchemaLike, JsonSchemaSchemaSource, ReflectionSchemaSource, Schema, SchemaInput, SchemaInputVariant, SchemaMetadata, SchemaSource, SchemaSourceInput, SchemaSourceVariant, StandardSchemaSchemaSource, TypeDefinitionReference, UntypedInputObject, UntypedSchema, UntypedSchemaSource, Zod3SchemaSource, bundle, extract, extractHash, extractJsonSchema, extractReflection, extractResolvedVariant, extractSchema, extractSchemaSchema, extractSource, extractVariant, generateCode, isExtractedSchema, isJTDSchema, isSchema, isUntypedInput, isUntypedSchema, jsonSchemaToJtd, reflectionToJsonSchema, resolve, resolveModule, resolveReflection };

package/dist/index.mjs

@@ -1,7 +1,9 @@
 import { bundle } from "./bundle.mjs";
-import { isSchemaDefinition } from "./is-schema-definition.mjs";
-import { objectReflectionToJsonSchema, reflectionToJsonSchema } from "./reflection.mjs";
+import { generateCode } from "./codegen.mjs";
+import { jsonSchemaToJtd } from "./jtd.mjs";
+import { reflectionToJsonSchema } from "./reflection.mjs";
 import { resolve, resolveModule, resolveReflection } from "./resolve.mjs";
-import { extract, extractJsonSchema, extractReflection, extractSchema } from "./extract.mjs";
+import { isExtractedSchema, isJTDSchema, isSchema, isUntypedInput, isUntypedSchema } from "./type-checks.mjs";
+import { extract, extractHash, extractJsonSchema, extractReflection, extractResolvedVariant, extractSchema, extractSchemaSchema, extractSource, extractVariant } from "./extract.mjs";
 
-export { bundle, extract, extractJsonSchema, extractReflection, extractSchema, isSchemaDefinition, objectReflectionToJsonSchema, reflectionToJsonSchema, resolve, resolveModule, resolveReflection };
+export { bundle, extract, extractHash, extractJsonSchema, extractReflection, extractResolvedVariant, extractSchema, extractSchemaSchema, extractSource, extractVariant, generateCode, isExtractedSchema, isJTDSchema, isSchema, isUntypedInput, isUntypedSchema, jsonSchemaToJtd, reflectionToJsonSchema, resolve, resolveModule, resolveReflection };

package/dist/jtd.cjs

@@ -0,0 +1,385 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
+let _stryke_type_checks = require("@stryke/type-checks");
+let _stryke_type_checks_is_set_object = require("@stryke/type-checks/is-set-object");
+
+//#region src/jtd.ts
+/**
+* Maps a JSON Schema `format` annotation for integers to the closest JTD numeric type.
+*
+* @param format - The JSON Schema format hint to map.
+* @returns The matching JTD numeric type, or `undefined` if no exact match exists.
+*/
+function jsonSchemaIntegerFormatToJtd(format) {
+	switch (format) {
+		case "int8": return "int8";
+		case "uint8": return "uint8";
+		case "int16": return "int16";
+		case "uint16": return "uint16";
+		case "int32": return "int32";
+		case "uint32": return "uint32";
+		case void 0:
+		default: return;
+	}
+}
+/**
+* Maps a JSON Schema `format` annotation for floating point numbers to the closest JTD numeric type.
+*
+* @param format - The JSON Schema format hint to map.
+* @returns The matching JTD numeric type, or `undefined` if no exact match exists.
+*/
+function jsonSchemaNumberFormatToJtd(format) {
+	switch (format) {
+		case "float":
+		case "float32": return "float32";
+		case "double":
+		case "float64": return "float64";
+		case void 0:
+		default: return;
+	}
+}
+/**
+* Picks the smallest unsigned JTD integer type that can hold the provided bounds.
+*
+* @param minimum - The inclusive lower bound, when known.
+* @param maximum - The inclusive upper bound, when known.
+* @returns The narrowest unsigned JTD integer type that can represent the range, or `undefined` if the range cannot be expressed as an unsigned integer.
+*/
+function pickUnsignedIntegerType(minimum, maximum) {
+	if (minimum === void 0 || minimum < 0) return;
+	if (maximum === void 0) return;
+	if (maximum <= 255) return "uint8";
+	if (maximum <= 65535) return "uint16";
+	if (maximum <= 4294967295) return "uint32";
+}
+/**
+* Picks the smallest signed JTD integer type that can hold the provided bounds.
+*
+* @param minimum - The inclusive lower bound, when known.
+* @param maximum - The inclusive upper bound, when known.
+* @returns The narrowest signed JTD integer type that can represent the range, or `undefined` if the range cannot be expressed as a signed integer.
+*/
+function pickSignedIntegerType(minimum, maximum) {
+	if (minimum !== void 0 && maximum !== void 0 && minimum >= -128 && maximum <= 127) return "int8";
+	if (minimum !== void 0 && maximum !== void 0 && minimum >= -32768 && maximum <= 32767) return "int16";
+	return "int32";
+}
+/**
+* Tests whether the provided value is a non-null object that can be inspected as a JSON Schema fragment.
+*
+* @param value - The value to test.
+* @returns `true` if the value is a plain object suitable for JSON-Schema conversion.
+*/
+function isJsonSchemaLike(value) {
+	return (0, _stryke_type_checks_is_set_object.isSetObject)(value);
+}
+/**
+* Reads the JSON Schema `type` field as an array, normalising the single-string form.
+*
+* @param schema - The JSON Schema fragment to inspect.
+* @returns The list of JSON Schema type names declared on the fragment.
+*/
+function readTypes(schema) {
+	if (Array.isArray(schema.type)) return schema.type;
+	if (typeof schema.type === "string") return [schema.type];
+	return [];
+}
+/**
+* Builds a JTD `metadata` object from the JSON Schema annotation keywords found on a fragment.
+*
+* @param schema - The source JSON Schema fragment.
+* @returns A metadata bag suitable for attaching to a JTD form, or `undefined` if no annotations are present.
+*/
+function collectMetadata(schema) {
+	const metadata = {};
+	if ((0, _stryke_type_checks.isSetString)(schema.description)) metadata.description = schema.description;
+	if ((0, _stryke_type_checks.isSetArray)(schema.examples)) metadata.examples = schema.examples;
+	if ((0, _stryke_type_checks.isSetArray)(schema.alias) && schema.alias.every(_stryke_type_checks.isSetString)) metadata.alias = schema.alias;
+	if ((0, _stryke_type_checks.isSetString)(schema.table)) metadata.default = schema.table;
+	if ((0, _stryke_type_checks.isSetString)(schema.title)) metadata.title = schema.title;
+	if (!(0, _stryke_type_checks.isUndefined)(schema.default)) metadata.default = schema.default;
+	if ((0, _stryke_type_checks.isBoolean)(schema.isHidden)) metadata.isHidden = schema.isHidden;
+	else if ((0, _stryke_type_checks.isBoolean)(schema.hidden)) metadata.isHidden = schema.hidden;
+	if ((0, _stryke_type_checks.isBoolean)(schema.isIgnored)) metadata.isIgnored = schema.isIgnored;
+	else if ((0, _stryke_type_checks.isBoolean)(schema.ignored)) metadata.isIgnored = schema.ignored;
+	if ((0, _stryke_type_checks.isBoolean)(schema.isReadonly)) metadata.isReadonly = schema.isReadonly;
+	else if ((0, _stryke_type_checks.isBoolean)(schema.readonly)) metadata.isReadonly = schema.readonly;
+	if ((0, _stryke_type_checks.isBoolean)(schema.isPrimaryKey)) metadata.isPrimaryKey = schema.isPrimaryKey;
+	else if ((0, _stryke_type_checks.isBoolean)(schema.primaryKey)) metadata.isPrimaryKey = schema.primaryKey;
+	if ((0, _stryke_type_checks.isBoolean)(schema.isInternal)) metadata.isInternal = schema.isInternal;
+	else if ((0, _stryke_type_checks.isBoolean)(schema.internal)) metadata.isInternal = schema.internal;
+	if ((0, _stryke_type_checks.isBoolean)(schema.isRuntime)) metadata.isRuntime = schema.isRuntime;
+	else if ((0, _stryke_type_checks.isBoolean)(schema.runtime)) metadata.isRuntime = schema.runtime;
+	if ((0, _stryke_type_checks.isSetArray)(schema.union)) metadata.union = schema.union;
+	return Object.keys(metadata).length > 0 ? metadata : void 0;
+}
+/**
+* Attaches metadata and nullability flags to a JTD form, mutating and returning the form.
+*
+* @param form - The base JTD form to decorate.
+* @param schema - The source JSON Schema fragment from which annotations are read.
+* @param nullable - Whether the schema is nullable in JTD semantics.
+* @returns The decorated JTD form.
+*/
+function decorate(form, schema, nullable) {
+	if (nullable) form.nullable = true;
+	const metadata = collectMetadata(schema);
+	if (metadata) form.metadata = metadata;
+	return form;
+}
+/**
+* Determines whether the supplied list of JSON Schema types collapses to `null` only.
+*
+* @param types - The normalized list of JSON Schema type names.
+* @returns `true` if the only declared type is `null`.
+*/
+function isNullOnly(types) {
+	return types.length > 0 && types.every((t) => t === "null");
+}
+/**
+* Splits a `null` declaration away from a list of JSON Schema types.
+*
+* @param types - The normalized list of JSON Schema type names.
+* @returns A tuple of `[nonNullTypes, nullable]` describing the remaining types and whether `null` was present.
+*/
+function stripNull(types) {
+	const nullable = types.includes("null");
+	return {
+		types: types.filter((t) => t !== "null"),
+		nullable
+	};
+}
+/**
+* Converts a JSON Schema `enum` keyword to a JTD enum form, stringifying values when required.
+*
+* @param values - The raw enum values from the JSON Schema fragment.
+* @returns A JTD enum form, or `undefined` if the enum cannot be represented (e.g. empty list).
+*/
+function enumToJtd(values) {
+	const strings = values.filter((v) => v !== null && v !== void 0).map((v) => String(v));
+	if (strings.length === 0) return;
+	return { enum: Array.from(new Set(strings)) };
+}
+/**
+* Selects the most appropriate JTD numeric `type` value for a JSON Schema integer fragment.
+*
+* @param schema - The integer JSON Schema fragment.
+* @returns The chosen JTD integer type.
+*/
+function pickIntegerJtdType(schema) {
+	const mapped = jsonSchemaIntegerFormatToJtd(schema.format);
+	if (mapped) return mapped;
+	const unsigned = pickUnsignedIntegerType(schema.minimum, schema.maximum);
+	if (unsigned) return unsigned;
+	return pickSignedIntegerType(schema.minimum, schema.maximum) ?? "int32";
+}
+/**
+* Selects the most appropriate JTD numeric `type` value for a JSON Schema number fragment.
+*
+* @param schema - The number JSON Schema fragment.
+* @returns The chosen JTD floating point type.
+*/
+function pickNumberJtdType(schema) {
+	return jsonSchemaNumberFormatToJtd(schema.format) ?? "float64";
+}
+/**
+* Selects the JTD string `type` value for a JSON Schema string fragment, mapping `format: "date-time"` to `timestamp`.
+*
+* @param schema - The string JSON Schema fragment.
+* @returns The chosen JTD string type.
+*/
+function pickStringJtdType(schema) {
+	if (schema.format === "date-time") return "timestamp";
+	return "string";
+}
+/**
+* Converts a JSON Schema object fragment into a JTD properties form.
+*
+* @param schema - The object JSON Schema fragment.
+* @param nullable - Whether the resulting JTD form should be nullable.
+* @returns The JTD properties form representing the object.
+*/
+function objectToJtd(schema, nullable) {
+	const required = new Set(schema.required ?? []);
+	const properties = {};
+	const optionalProperties = {};
+	const metadata = { default: schema.default ?? {} };
+	if (schema.properties) for (const [key, value] of Object.entries(schema.properties)) {
+		if (!(0, _stryke_type_checks.isUndefined)(value.default)) metadata.default[key] = value.default;
+		const converted = jsonSchemaToJtd(value);
+		if (!converted) continue;
+		if (required.has(key)) properties[key] = converted;
+		else optionalProperties[key] = converted;
+	}
+	const hasProperties = Object.keys(properties).length > 0;
+	const hasOptional = Object.keys(optionalProperties).length > 0;
+	if (!hasProperties && !hasOptional && isJsonSchemaLike(schema.additionalProperties)) {
+		const values = jsonSchemaToJtd(schema.additionalProperties);
+		if (values) return decorate({
+			metadata,
+			values
+		}, schema, nullable);
+	}
+	if (!hasProperties && !hasOptional && schema.patternProperties) {
+		const first = Object.values(schema.patternProperties)[0];
+		if (first) {
+			const values = jsonSchemaToJtd(first);
+			if (values) return decorate({
+				metadata,
+				values
+			}, schema, nullable);
+		}
+	}
+	const form = { metadata };
+	if (hasProperties) form.properties = properties;
+	else if (!hasOptional) form.properties = {};
+	if (hasOptional) form.optionalProperties = optionalProperties;
+	if (schema.additionalProperties === true || isJsonSchemaLike(schema.additionalProperties) || schema.patternProperties !== void 0) form.additionalProperties = true;
+	return decorate(form, schema, nullable);
+}
+/**
+* Converts a JSON Schema array fragment into a JTD elements form.
+*
+* @param schema - The array JSON Schema fragment.
+* @param nullable - Whether the resulting JTD form should be nullable.
+* @returns The JTD elements form representing the array.
+*/
+function arrayToJtd(schema, nullable) {
+	let elementSchema;
+	if (Array.isArray(schema.items)) elementSchema = schema.items[0];
+	else if (schema.items) elementSchema = schema.items;
+	return decorate({ elements: (elementSchema ? jsonSchemaToJtd(elementSchema) : {}) ?? {} }, schema, nullable);
+}
+/**
+* Attempts to detect and emit a JTD discriminator form from a JSON Schema `oneOf` or `anyOf` fragment.
+*
+* @param schemas - The list of candidate JSON Schema fragments.
+* @param nullable - Whether the resulting JTD form should be nullable.
+* @returns A discriminator form when every branch shares a single tag property, otherwise `undefined`.
+*/
+function tryDiscriminator(schemas, nullable) {
+	if (schemas.length < 2) return;
+	let candidateKey;
+	const mapping = {};
+	for (const branch of schemas) {
+		if (!isJsonSchemaLike(branch) || !branch.properties) return;
+		const constantTags = Object.entries(branch.properties).filter(([, value]) => isJsonSchemaLike(value) && (typeof value.const === "string" || Array.isArray(value.enum) && value.enum.length === 1 && typeof value.enum[0] === "string"));
+		if (constantTags.length === 0) return;
+		const [tagKey, tagSchema] = constantTags[0];
+		if (!candidateKey) candidateKey = tagKey;
+		else if (candidateKey !== tagKey) return;
+		const tag = typeof tagSchema.const === "string" ? tagSchema.const : tagSchema.enum?.[0];
+		const { [tagKey]: _omit, ...restProperties } = branch.properties;
+		const restRequired = (branch.required ?? []).filter((k) => k !== tagKey);
+		const branchForm = jsonSchemaToJtd({
+			...branch,
+			properties: restProperties,
+			required: restRequired
+		});
+		if (!branchForm || !(0, _stryke_type_checks_is_set_object.isSetObject)(branchForm) || "ref" in branchForm) return;
+		mapping[tag] = branchForm;
+	}
+	if (!candidateKey) return;
+	const form = {
+		discriminator: candidateKey,
+		mapping
+	};
+	if (nullable) form.nullable = true;
+	return form;
+}
+/**
+* Converts a JSON Schema fragment (draft-07 style, as produced by `zod-to-json-schema`, Standard Schema, etc.) into a valid JSON Type Definition (RFC 8927) schema.
+*
+* Unsupported JSON Schema keywords (`pattern`, `const`, `minItems`, `maxItems`, `uniqueItems`, etc.) are dropped — JTD intentionally omits these. Annotation keywords (`description`, `title`, `default`, `examples`) are preserved under the JTD `metadata` field.
+*
+* @param schema - The JSON Schema fragment to convert.
+* @returns A valid JTD form, or `undefined` if the input cannot be represented.
+*/
+function jsonSchemaToJtd(schema) {
+	if (!isJsonSchemaLike(schema)) return;
+	if ((0, _stryke_type_checks.isSetString)(schema.$ref)) {
+		const match = /^#\/(?:definitions|\$defs)\/(.+)$/.exec(schema.$ref);
+		if (match) return { ref: match[1] };
+	}
+	if (Array.isArray(schema.allOf) && schema.allOf.length > 0) {
+		const merged = schema.allOf.reduce((acc, current) => mergeJsonSchema(acc, current), {});
+		const { allOf: _allOf, ...rest } = schema;
+		return jsonSchemaToJtd(mergeJsonSchema(merged, rest));
+	}
+	const rawTypes = readTypes(schema);
+	const { types: nonNullTypes, nullable: typeIsNullable } = stripNull(rawTypes);
+	const nullable = Boolean(schema.nullable) || typeIsNullable;
+	if (isNullOnly(rawTypes)) return decorate({}, schema, true);
+	if (Array.isArray(schema.enum)) {
+		const enumForm = enumToJtd(schema.enum);
+		if (enumForm) return decorate(enumForm, schema, nullable);
+	}
+	if ((0, _stryke_type_checks.isSetString)(schema.const)) return decorate({ enum: [schema.const] }, schema, nullable);
+	const union = schema.oneOf ?? schema.anyOf;
+	if (Array.isArray(union) && union.length > 0) {
+		const branches = union.filter(isJsonSchemaLike);
+		const onlyNullBranches = branches.filter((b) => readTypes(b).includes("null"));
+		const nonNullBranches = branches.filter((b) => !isNullOnly(readTypes(b)) && readTypes(b).join() !== "null");
+		const unionNullable = nullable || onlyNullBranches.length > 0;
+		if (nonNullBranches.length === 1) {
+			const collapsed = jsonSchemaToJtd(nonNullBranches[0]);
+			if (collapsed) return decorate(collapsed, schema, unionNullable);
+		}
+		const discriminated = tryDiscriminator(nonNullBranches, unionNullable);
+		if (discriminated) {
+			const metadata = collectMetadata(schema);
+			if (metadata) discriminated.metadata = metadata;
+			return discriminated;
+		}
+		const fallback = decorate({}, schema, unionNullable);
+		const metadata = fallback.metadata ?? {};
+		metadata.union = union;
+		fallback.metadata = metadata;
+		return fallback;
+	}
+	if (nonNullTypes.includes("object") || schema.properties || schema.patternProperties || isJsonSchemaLike(schema.additionalProperties)) {
+		const result = objectToJtd(schema, nullable);
+		const definitions = schema.definitions ?? schema.$defs;
+		if (definitions && Object.keys(definitions).length > 0) {
+			const converted = {};
+			for (const [key, value] of Object.entries(definitions)) {
+				const def = jsonSchemaToJtd(value);
+				if (def) converted[key] = def;
+			}
+			if (Object.keys(converted).length > 0) result.definitions = converted;
+		}
+		return result;
+	}
+	if (nonNullTypes.includes("array")) return arrayToJtd(schema, nullable);
+	if (nonNullTypes.length === 1) {
+		const t = nonNullTypes[0];
+		if (t === "string") return decorate({ type: pickStringJtdType(schema) }, schema, nullable);
+		if (t === "boolean") return decorate({ type: "boolean" }, schema, nullable);
+		if (t === "integer") return decorate({ type: pickIntegerJtdType(schema) }, schema, nullable);
+		if (t === "number") return decorate({ type: pickNumberJtdType(schema) }, schema, nullable);
+	}
+	if (nonNullTypes.length > 1) return decorate({}, schema, nullable);
+	return decorate({}, schema, nullable);
+}
+/**
+* Shallow-merges two JSON Schema fragments, combining `required` arrays and `properties` maps.
+*
+* @param left - The base schema fragment.
+* @param right - The schema fragment to merge into the base.
+* @returns A merged schema fragment. Neither input is mutated.
+*/
+function mergeJsonSchema(left, right) {
+	const merged = {
+		...left,
+		...right
+	};
+	if (left.properties || right.properties) merged.properties = {
+		...left.properties ?? {},
+		...right.properties ?? {}
+	};
+	if (left.required || right.required) merged.required = Array.from(new Set([...left.required ?? [], ...right.required ?? []]));
+	return merged;
+}
+
+//#endregion
+exports.jsonSchemaToJtd = jsonSchemaToJtd;

package/dist/jtd.d.cts

@@ -0,0 +1,15 @@
+import { JTDSchemaType, JsonSchemaLike, SchemaMetadata } from "./types.cjs";
+
+//#region src/jtd.d.ts
+/**
+ * Converts a JSON Schema fragment (draft-07 style, as produced by `zod-to-json-schema`, Standard Schema, etc.) into a valid JSON Type Definition (RFC 8927) schema.
+ *
+ * Unsupported JSON Schema keywords (`pattern`, `const`, `minItems`, `maxItems`, `uniqueItems`, etc.) are dropped — JTD intentionally omits these. Annotation keywords (`description`, `title`, `default`, `examples`) are preserved under the JTD `metadata` field.
+ *
+ * @param schema - The JSON Schema fragment to convert.
+ * @returns A valid JTD form, or `undefined` if the input cannot be represented.
+ */
+declare function jsonSchemaToJtd<TMetadata extends Partial<SchemaMetadata> = Partial<SchemaMetadata>>(schema: JsonSchemaLike | undefined | null): JTDSchemaType<TMetadata> | undefined;
+//#endregion
+export { jsonSchemaToJtd };
+//# sourceMappingURL=jtd.d.cts.map

package/dist/jtd.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jtd.d.cts","names":[],"sources":["../src/jtd.ts"],"mappings":";;;;;AAgjBA;;;;;;iBAAgB,eAAA,mBACI,OAAA,CAAQ,cAAA,IAAkB,OAAA,CAAQ,cAAA,EAAA,CAEpD,MAAA,EAAQ,cAAA,sBACP,aAAA,CAAc,SAAA"}

package/dist/jtd.d.mts

@@ -0,0 +1,15 @@
+import { JTDSchemaType, JsonSchemaLike, SchemaMetadata } from "./types.mjs";
+
+//#region src/jtd.d.ts
+/**
+ * Converts a JSON Schema fragment (draft-07 style, as produced by `zod-to-json-schema`, Standard Schema, etc.) into a valid JSON Type Definition (RFC 8927) schema.
+ *
+ * Unsupported JSON Schema keywords (`pattern`, `const`, `minItems`, `maxItems`, `uniqueItems`, etc.) are dropped — JTD intentionally omits these. Annotation keywords (`description`, `title`, `default`, `examples`) are preserved under the JTD `metadata` field.
+ *
+ * @param schema - The JSON Schema fragment to convert.
+ * @returns A valid JTD form, or `undefined` if the input cannot be represented.
+ */
+declare function jsonSchemaToJtd<TMetadata extends Partial<SchemaMetadata> = Partial<SchemaMetadata>>(schema: JsonSchemaLike | undefined | null): JTDSchemaType<TMetadata> | undefined;
+//#endregion
+export { jsonSchemaToJtd };
+//# sourceMappingURL=jtd.d.mts.map

package/dist/jtd.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jtd.d.mts","names":[],"sources":["../src/jtd.ts"],"mappings":";;;;;AAgjBA;;;;;;iBAAgB,eAAA,mBACI,OAAA,CAAQ,cAAA,IAAkB,OAAA,CAAQ,cAAA,EAAA,CAEpD,MAAA,EAAQ,cAAA,sBACP,aAAA,CAAc,SAAA"}