@geekmidas/schema 0.0.1

package/README.md

@@ -0,0 +1,351 @@
+# @geekmidas/schema
+
+Type utilities for working with StandardSchema-compatible validation libraries. Provides type inference helpers that work with any validation library implementing the StandardSchema specification (Zod, Valibot, ArkType, etc.).
+
+## Features
+
+- ✅ **Type Inference**: Extract output types from StandardSchema instances
+- ✅ **Composable Schemas**: Support for object-based schema composition
+- ✅ **Zero Runtime Overhead**: Pure TypeScript types with no runtime code
+- ✅ **Universal Compatibility**: Works with any StandardSchema-compatible library
+- ✅ **Type Safety**: Full TypeScript type inference and checking
+
+## Installation
+
+```bash
+pnpm add @geekmidas/schema
+```
+
+## What is StandardSchema?
+
+[StandardSchema](https://github.com/standard-schema/standard-schema) is a standard for schema validation libraries in TypeScript/JavaScript. It provides a unified interface that allows different validation libraries (Zod, Valibot, ArkType, etc.) to be used interchangeably.
+
+This package provides TypeScript utilities to work with StandardSchema-compatible types.
+
+## API Reference
+
+### `InferStandardSchema<T>`
+
+Infers the output type from a StandardSchema instance.
+
+```typescript
+type InferStandardSchema<T> = T extends StandardSchemaV1
+  ? StandardSchemaV1.InferOutput<T>
+  : never;
+```
+
+### `ComposableStandardSchema`
+
+Type for composable schemas - can be a single schema or an object of schemas.
+
+```typescript
+type ComposableStandardSchema =
+  | StandardSchemaV1
+  | {
+      [key: string]: StandardSchemaV1 | undefined;
+    };
+```
+
+### `InferComposableStandardSchema<T>`
+
+Infers types from composable schemas, supporting both single schemas and schema objects.
+
+```typescript
+type InferComposableStandardSchema<T> = T extends StandardSchemaV1
+  ? StandardSchemaV1.InferOutput<T>
+  : T extends { [key: string]: StandardSchemaV1 | undefined }
+    ? {
+        [K in keyof T as T[K] extends StandardSchemaV1
+          ? K
+          : never]: T[K] extends StandardSchemaV1
+          ? StandardSchemaV1.InferOutput<T[K]>
+          : never;
+      }
+    : {};
+```
+
+## Usage with Zod
+
+```typescript
+import type { InferStandardSchema } from '@geekmidas/schema';
+import { z } from 'zod';
+
+// Define a schema
+const userSchema = z.object({
+  id: z.string(),
+  email: z.string().email(),
+  age: z.number().min(18),
+  role: z.enum(['admin', 'user'])
+});
+
+// Infer the type
+type User = InferStandardSchema<typeof userSchema>;
+// type User = {
+//   id: string;
+//   email: string;
+//   age: number;
+//   role: 'admin' | 'user';
+// }
+
+// Use the type
+function processUser(user: User) {
+  console.log(user.email);
+}
+```
+
+## Usage with Valibot
+
+```typescript
+import type { InferStandardSchema } from '@geekmidas/schema';
+import * as v from 'valibot';
+
+const productSchema = v.object({
+  id: v.string(),
+  name: v.string(),
+  price: v.number(),
+  inStock: v.boolean()
+});
+
+type Product = InferStandardSchema<typeof productSchema>;
+// type Product = {
+//   id: string;
+//   name: string;
+//   price: number;
+//   inStock: boolean;
+// }
+```
+
+## Composable Schemas
+
+Use `ComposableStandardSchema` and `InferComposableStandardSchema` to work with multiple schemas:
+
+```typescript
+import type {
+  ComposableStandardSchema,
+  InferComposableStandardSchema
+} from '@geekmidas/schema';
+import { z } from 'zod';
+
+// Define multiple schemas
+const schemas = {
+  user: z.object({
+    id: z.string(),
+    email: z.string().email()
+  }),
+  post: z.object({
+    id: z.string(),
+    title: z.string(),
+    authorId: z.string()
+  }),
+  comment: z.object({
+    id: z.string(),
+    content: z.string(),
+    postId: z.string()
+  })
+} satisfies Record<string, ComposableStandardSchema>;
+
+// Infer types from all schemas
+type Schemas = InferComposableStandardSchema<typeof schemas>;
+// type Schemas = {
+//   user: { id: string; email: string };
+//   post: { id: string; title: string; authorId: string };
+//   comment: { id: string; content: string; postId: string };
+// }
+
+// Use individual types
+type User = Schemas['user'];
+type Post = Schemas['post'];
+type Comment = Schemas['comment'];
+```
+
+## Generic Functions
+
+Create generic functions that work with any StandardSchema:
+
+```typescript
+import type { InferStandardSchema } from '@geekmidas/schema';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+
+function validateData<T extends StandardSchemaV1>(
+  schema: T,
+  data: unknown
+): InferStandardSchema<T> | null {
+  const result = schema['~standard'].validate(data);
+
+  if (result.issues) {
+    console.error('Validation failed:', result.issues);
+    return null;
+  }
+
+  return result.value as InferStandardSchema<T>;
+}
+
+// Usage with any schema
+const userSchema = z.object({ name: z.string() });
+const validatedUser = validateData(userSchema, { name: 'John' });
+// validatedUser is typed as { name: string } | null
+```
+
+## Factory Pattern
+
+Use composable schemas in factory patterns:
+
+```typescript
+import type {
+  ComposableStandardSchema,
+  InferComposableStandardSchema
+} from '@geekmidas/schema';
+
+class SchemaFactory<T extends Record<string, ComposableStandardSchema>> {
+  constructor(private schemas: T) {}
+
+  validate<K extends keyof T>(
+    key: K,
+    data: unknown
+  ): InferComposableStandardSchema<T>[K] | null {
+    const schema = this.schemas[key];
+    if (!schema) return null;
+
+    const result = schema['~standard'].validate(data);
+    return result.issues ? null : result.value;
+  }
+
+  getSchema<K extends keyof T>(key: K): T[K] {
+    return this.schemas[key];
+  }
+}
+
+// Usage
+const schemas = {
+  user: z.object({ name: z.string() }),
+  product: z.object({ sku: z.string(), price: z.number() })
+};
+
+const factory = new SchemaFactory(schemas);
+const user = factory.validate('user', { name: 'John' });
+// user is typed as { name: string } | null
+```
+
+## API Endpoint Validation
+
+Common pattern for API endpoint validation:
+
+```typescript
+import type { InferStandardSchema } from '@geekmidas/schema';
+import { z } from 'zod';
+
+const createUserEndpoint = {
+  body: z.object({
+    name: z.string().min(1),
+    email: z.string().email(),
+    age: z.number().int().min(18)
+  }),
+  response: z.object({
+    id: z.string(),
+    name: z.string(),
+    email: z.string()
+  })
+};
+
+type CreateUserBody = InferStandardSchema<typeof createUserEndpoint.body>;
+type CreateUserResponse = InferStandardSchema<typeof createUserEndpoint.response>;
+
+async function createUser(
+  data: CreateUserBody
+): Promise<CreateUserResponse> {
+  // Implementation with fully typed request and response
+  return {
+    id: '123',
+    name: data.name,
+    email: data.email
+  };
+}
+```
+
+## Type Guards
+
+Create type guards using schema inference:
+
+```typescript
+import type { InferStandardSchema } from '@geekmidas/schema';
+import { z } from 'zod';
+
+const userSchema = z.object({
+  id: z.string(),
+  email: z.string().email()
+});
+
+type User = InferStandardSchema<typeof userSchema>;
+
+function isUser(value: unknown): value is User {
+  const result = userSchema.safeParse(value);
+  return result.success;
+}
+
+// Usage
+const data: unknown = { id: '123', email: 'user@example.com' };
+
+if (isUser(data)) {
+  // data is now typed as User
+  console.log(data.email);
+}
+```
+
+## Integration with @geekmidas/constructs
+
+This package is used internally by `@geekmidas/constructs` for type-safe endpoint validation:
+
+```typescript
+import { e } from '@geekmidas/constructs/endpoints';
+import { z } from 'zod';
+
+// The constructs package uses InferStandardSchema internally
+const endpoint = e
+  .post('/users')
+  .body(z.object({ name: z.string() }))
+  .output(z.object({ id: z.string() }))
+  .handle(async ({ body }) => {
+    // body is automatically typed as { name: string }
+    return { id: '123' };
+  });
+```
+
+## Why Use This Package?
+
+1. **Type Safety**: Ensures your types match your runtime validation schemas
+2. **DRY Principle**: Define schemas once, derive types automatically
+3. **Refactoring Safety**: Changing schemas automatically updates types
+4. **Universal**: Works with any StandardSchema-compatible library
+5. **Zero Cost**: Pure TypeScript types with no runtime overhead
+
+## Supported Validation Libraries
+
+Any library implementing the StandardSchema specification, including:
+
+- [Zod](https://github.com/colinhacks/zod)
+- [Valibot](https://github.com/fabian-hiller/valibot)
+- [ArkType](https://github.com/arktypeio/arktype)
+- And any future StandardSchema-compatible library
+
+## TypeScript Configuration
+
+Requires TypeScript 5.0 or higher with strict mode enabled:
+
+```json
+{
+  "compilerOptions": {
+    "strict": true,
+    "strictNullChecks": true
+  }
+}
+```
+
+## Related Packages
+
+- [@geekmidas/constructs](../constructs) - Uses this package for endpoint validation
+- [@geekmidas/envkit](../envkit) - Environment configuration with schema validation
+- [@standard-schema/spec](https://github.com/standard-schema/standard-schema) - StandardSchema specification
+
+## License
+
+MIT

package/dist/conversion-CH_EmflL.d.cts

@@ -0,0 +1,30 @@
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/conversion.d.ts
+declare enum SchemaVendor {
+  zod = "zod",
+  valibot = "valibot",
+}
+type VendorConvertor = (schema: any) => Promise<any>;
+type VendorConvertors = Record<SchemaVendor, VendorConvertor>;
+declare const StandardSchemaJsonSchema: VendorConvertors;
+declare function convertStandardSchemaToJsonSchema(schema?: StandardSchemaV1, componentCollector?: {
+  addSchema(id: string, schema: any): void;
+  getReference(id: string): {
+    $ref: string;
+  };
+}): Promise<any>;
+declare function getZodMetadata(schema: StandardSchemaV1): Promise<SchemaMeta | undefined>;
+declare function getSchemaMetadata(schema: StandardSchemaV1): Promise<SchemaMeta | undefined>;
+interface SchemaMeta {
+  id?: string;
+}
+declare function convertSchemaWithComponents(schema: StandardSchemaV1 | undefined, componentCollector?: {
+  addSchema(id: string, schema: any): void;
+  getReference(id: string): {
+    $ref: string;
+  };
+}): Promise<any>;
+//#endregion
+export { SchemaVendor, StandardSchemaJsonSchema, VendorConvertor, VendorConvertors, convertSchemaWithComponents, convertStandardSchemaToJsonSchema, getSchemaMetadata, getZodMetadata };
+//# sourceMappingURL=conversion-CH_EmflL.d.cts.map

package/dist/conversion-Civd6bIU.mjs

@@ -0,0 +1,89 @@
+//#region src/conversion.ts
+let SchemaVendor = /* @__PURE__ */ function(SchemaVendor$1) {
+	SchemaVendor$1["zod"] = "zod";
+	SchemaVendor$1["valibot"] = "valibot";
+	return SchemaVendor$1;
+}({});
+function isSchemaVendor(vendor) {
+	if (!vendor) return false;
+	return Object.values(SchemaVendor).includes(vendor);
+}
+const StandardSchemaJsonSchema = {
+	zod: async (schema) => {
+		try {
+			const { z } = await import("zod/v4").catch(() => ({ z: {} }));
+			if ("toJSONSchema" in z && typeof z.toJSONSchema === "function") return z.toJSONSchema(schema);
+			const { zodToJsonSchema } = await import("zod-to-json-schema");
+			const result = zodToJsonSchema(schema, { removeAdditionalStrategy: "strict" });
+			return result;
+		} catch (error) {
+			console.warn("zod-to-json-schema not available, using basic conversion", error);
+			return { type: "object" };
+		}
+	},
+	valibot: async (schema) => {
+		const { toJsonSchema } = await import("@valibot/to-json-schema");
+		return toJsonSchema(schema);
+	}
+};
+function extractAndConvertDefs(jsonSchema, componentCollector) {
+	if (!jsonSchema || typeof jsonSchema !== "object") return jsonSchema;
+	const processSchema = (schema) => {
+		if (!schema || typeof schema !== "object") return schema;
+		if (schema.$ref && typeof schema.$ref === "string") {
+			if (schema.$ref.startsWith("#/$defs/")) {
+				const refName = schema.$ref.replace("#/$defs/", "");
+				return componentCollector ? componentCollector.getReference(refName) : schema;
+			}
+			return schema;
+		}
+		if (Array.isArray(schema)) return schema.map(processSchema);
+		const processed = {};
+		for (const [key, value] of Object.entries(schema)) {
+			if (key === "$defs") continue;
+			processed[key] = processSchema(value);
+		}
+		return processed;
+	};
+	if (jsonSchema.$defs && componentCollector) for (const [defName, defSchema] of Object.entries(jsonSchema.$defs)) {
+		const processedDefSchema = processSchema(defSchema);
+		componentCollector.addSchema(defName, processedDefSchema);
+	}
+	const { $defs,...schemaWithoutDefs } = jsonSchema;
+	return processSchema(schemaWithoutDefs);
+}
+async function convertStandardSchemaToJsonSchema(schema, componentCollector) {
+	if (!schema) return void 0;
+	const vendor = schema["~standard"]?.vendor;
+	if (!isSchemaVendor(vendor)) throw new Error(`Unsupported or missing vendor "${vendor}" for Standard Schema. Supported vendors are: ${Object.keys(StandardSchemaJsonSchema).join(", ")}`);
+	const toJSONSchema = StandardSchemaJsonSchema[vendor];
+	const jsonSchema = await toJSONSchema(schema);
+	return extractAndConvertDefs(jsonSchema, componentCollector);
+}
+async function getZodMetadata(schema) {
+	const { ZodObject } = await import("zod/v4");
+	if (schema instanceof ZodObject) return schema.meta();
+	return void 0;
+}
+async function getSchemaMetadata(schema) {
+	const vendor = schema["~standard"]?.vendor;
+	if (vendor === "zod") return getZodMetadata(schema);
+	return void 0;
+}
+async function convertSchemaWithComponents(schema, componentCollector) {
+	if (!schema) return void 0;
+	const jsonSchema = await convertStandardSchemaToJsonSchema(schema, componentCollector);
+	if (!componentCollector) return jsonSchema;
+	const metadata = await getSchemaMetadata(schema);
+	const schemaId = metadata?.id || jsonSchema?.id;
+	if (schemaId) {
+		const { id,...schemaWithoutId } = jsonSchema;
+		componentCollector.addSchema(schemaId, schemaWithoutId);
+		return componentCollector.getReference(schemaId);
+	}
+	return jsonSchema;
+}
+
+//#endregion
+export { SchemaVendor, StandardSchemaJsonSchema, convertSchemaWithComponents, convertStandardSchemaToJsonSchema, getSchemaMetadata, getZodMetadata };
+//# sourceMappingURL=conversion-Civd6bIU.mjs.map

package/dist/conversion-Civd6bIU.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversion-Civd6bIU.mjs","names":["vendor?: string","StandardSchemaJsonSchema: VendorConvertors","jsonSchema: any","componentCollector?: {\n    addSchema(id: string, schema: any): void;\n    getReference(id: string): { $ref: string };\n  }","schema: any","processed: any","schema?: StandardSchemaV1","schema: StandardSchemaV1","schema: StandardSchemaV1 | undefined"],"sources":["../src/conversion.ts"],"sourcesContent":["import type { StandardSchemaV1 } from '@standard-schema/spec';\n\nexport enum SchemaVendor {\n  zod = 'zod',\n  valibot = 'valibot',\n}\n\nexport type VendorConvertor = (schema: any) => Promise<any>;\nexport type VendorConvertors = Record<SchemaVendor, VendorConvertor>;\n\nfunction isSchemaVendor(vendor?: string): vendor is SchemaVendor {\n  if (!vendor) {\n    return false;\n  }\n\n  return Object.values(SchemaVendor).includes(vendor as SchemaVendor);\n}\n\nexport const StandardSchemaJsonSchema: VendorConvertors = {\n  zod: async (schema): Promise<any> => {\n    try {\n      const { z } = await import('zod/v4').catch(() => ({ z: {} }));\n\n      if ('toJSONSchema' in z && typeof z.toJSONSchema === 'function') {\n        return z.toJSONSchema(schema);\n      }\n      const { zodToJsonSchema } = await import('zod-to-json-schema');\n\n      const result = zodToJsonSchema(schema, {\n        removeAdditionalStrategy: 'strict',\n      });\n\n      return result;\n    } catch (error) {\n      // Fallback to basic conversion if zod-to-json-schema is not available\n      console.warn(\n        'zod-to-json-schema not available, using basic conversion',\n        error,\n      );\n      return { type: 'object' };\n    }\n  },\n  valibot: async (schema): Promise<any> => {\n    const { toJsonSchema } = await import('@valibot/to-json-schema');\n    return toJsonSchema(schema as any);\n  },\n};\n\nfunction extractAndConvertDefs(\n  jsonSchema: any,\n  componentCollector?: {\n    addSchema(id: string, schema: any): void;\n    getReference(id: string): { $ref: string };\n  },\n): any {\n  if (!jsonSchema || typeof jsonSchema !== 'object') {\n    return jsonSchema;\n  }\n\n  // Process the schema recursively to update references\n  const processSchema = (schema: any): any => {\n    if (!schema || typeof schema !== 'object') {\n      return schema;\n    }\n\n    // Handle $ref\n    if (schema.$ref && typeof schema.$ref === 'string') {\n      // Convert #/$defs/X to #/components/schemas/X\n      if (schema.$ref.startsWith('#/$defs/')) {\n        const refName = schema.$ref.replace('#/$defs/', '');\n        return componentCollector\n          ? componentCollector.getReference(refName)\n          : schema;\n      }\n      return schema;\n    }\n\n    // Handle arrays\n    if (Array.isArray(schema)) {\n      return schema.map(processSchema);\n    }\n\n    // Process all properties recursively\n    const processed: any = {};\n    for (const [key, value] of Object.entries(schema)) {\n      if (key === '$defs') {\n        // Skip $defs as they've been extracted\n        continue;\n      }\n      processed[key] = processSchema(value);\n    }\n    return processed;\n  };\n\n  // Extract $defs if present\n  if (jsonSchema.$defs && componentCollector) {\n    for (const [defName, defSchema] of Object.entries(jsonSchema.$defs)) {\n      // Process the definition recursively to handle nested $refs\n      const processedDefSchema = processSchema(defSchema);\n      // Add each definition to the component collector\n      componentCollector.addSchema(defName, processedDefSchema);\n    }\n  }\n\n  // Process the schema and remove $defs\n  const { $defs, ...schemaWithoutDefs } = jsonSchema;\n  return processSchema(schemaWithoutDefs);\n}\n\nexport async function convertStandardSchemaToJsonSchema(\n  schema?: StandardSchemaV1,\n  componentCollector?: {\n    addSchema(id: string, schema: any): void;\n    getReference(id: string): { $ref: string };\n  },\n): Promise<any> {\n  if (!schema) {\n    return undefined;\n  }\n\n  const vendor = schema['~standard']?.vendor;\n  if (!isSchemaVendor(vendor)) {\n    throw new Error(\n      `Unsupported or missing vendor \"${vendor}\" for Standard Schema. Supported vendors are: ${Object.keys(StandardSchemaJsonSchema).join(', ')}`,\n    );\n  }\n\n  const toJSONSchema = StandardSchemaJsonSchema[vendor];\n  const jsonSchema = await toJSONSchema(schema);\n\n  // Extract and convert $defs to components\n  return extractAndConvertDefs(jsonSchema, componentCollector);\n}\n\nexport async function getZodMetadata(\n  schema: StandardSchemaV1,\n): Promise<SchemaMeta | undefined> {\n  const { ZodObject } = await import('zod/v4');\n\n  if (schema instanceof ZodObject) {\n    return schema.meta();\n  }\n\n  return undefined;\n}\n\nexport async function getSchemaMetadata(\n  schema: StandardSchemaV1,\n): Promise<SchemaMeta | undefined> {\n  const vendor = schema['~standard']?.vendor;\n\n  if (vendor === 'zod') {\n    return getZodMetadata(schema);\n  }\n\n  return undefined;\n}\n\ninterface SchemaMeta {\n  id?: string;\n}\n\nexport async function convertSchemaWithComponents(\n  schema: StandardSchemaV1 | undefined,\n  componentCollector?: {\n    addSchema(id: string, schema: any): void;\n    getReference(id: string): { $ref: string };\n  },\n): Promise<any> {\n  if (!schema) {\n    return undefined;\n  }\n\n  // Convert to JSON Schema with component collector to handle $defs\n  const jsonSchema = await convertStandardSchemaToJsonSchema(\n    schema,\n    componentCollector,\n  );\n\n  if (!componentCollector) {\n    return jsonSchema;\n  }\n\n  // Check if this schema has metadata with an ID\n  const metadata = await getSchemaMetadata(schema);\n\n  // Also check if the JSON Schema itself has an id field (from Zod's meta)\n  const schemaId = metadata?.id || jsonSchema?.id;\n\n  if (schemaId) {\n    // Remove the id from the schema before adding to components\n    const { id, ...schemaWithoutId } = jsonSchema;\n    // Add this schema to components and return a reference\n    componentCollector.addSchema(schemaId, schemaWithoutId);\n    return componentCollector.getReference(schemaId);\n  }\n\n  return jsonSchema;\n}\n"],"mappings":"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"}

package/dist/conversion-CrSNoSRa.cjs

@@ -0,0 +1,125 @@
+
+//#region src/conversion.ts
+let SchemaVendor = /* @__PURE__ */ function(SchemaVendor$1) {
+	SchemaVendor$1["zod"] = "zod";
+	SchemaVendor$1["valibot"] = "valibot";
+	return SchemaVendor$1;
+}({});
+function isSchemaVendor(vendor) {
+	if (!vendor) return false;
+	return Object.values(SchemaVendor).includes(vendor);
+}
+const StandardSchemaJsonSchema = {
+	zod: async (schema) => {
+		try {
+			const { z } = await import("zod/v4").catch(() => ({ z: {} }));
+			if ("toJSONSchema" in z && typeof z.toJSONSchema === "function") return z.toJSONSchema(schema);
+			const { zodToJsonSchema } = await import("zod-to-json-schema");
+			const result = zodToJsonSchema(schema, { removeAdditionalStrategy: "strict" });
+			return result;
+		} catch (error) {
+			console.warn("zod-to-json-schema not available, using basic conversion", error);
+			return { type: "object" };
+		}
+	},
+	valibot: async (schema) => {
+		const { toJsonSchema } = await import("@valibot/to-json-schema");
+		return toJsonSchema(schema);
+	}
+};
+function extractAndConvertDefs(jsonSchema, componentCollector) {
+	if (!jsonSchema || typeof jsonSchema !== "object") return jsonSchema;
+	const processSchema = (schema) => {
+		if (!schema || typeof schema !== "object") return schema;
+		if (schema.$ref && typeof schema.$ref === "string") {
+			if (schema.$ref.startsWith("#/$defs/")) {
+				const refName = schema.$ref.replace("#/$defs/", "");
+				return componentCollector ? componentCollector.getReference(refName) : schema;
+			}
+			return schema;
+		}
+		if (Array.isArray(schema)) return schema.map(processSchema);
+		const processed = {};
+		for (const [key, value] of Object.entries(schema)) {
+			if (key === "$defs") continue;
+			processed[key] = processSchema(value);
+		}
+		return processed;
+	};
+	if (jsonSchema.$defs && componentCollector) for (const [defName, defSchema] of Object.entries(jsonSchema.$defs)) {
+		const processedDefSchema = processSchema(defSchema);
+		componentCollector.addSchema(defName, processedDefSchema);
+	}
+	const { $defs,...schemaWithoutDefs } = jsonSchema;
+	return processSchema(schemaWithoutDefs);
+}
+async function convertStandardSchemaToJsonSchema(schema, componentCollector) {
+	if (!schema) return void 0;
+	const vendor = schema["~standard"]?.vendor;
+	if (!isSchemaVendor(vendor)) throw new Error(`Unsupported or missing vendor "${vendor}" for Standard Schema. Supported vendors are: ${Object.keys(StandardSchemaJsonSchema).join(", ")}`);
+	const toJSONSchema = StandardSchemaJsonSchema[vendor];
+	const jsonSchema = await toJSONSchema(schema);
+	return extractAndConvertDefs(jsonSchema, componentCollector);
+}
+async function getZodMetadata(schema) {
+	const { ZodObject } = await import("zod/v4");
+	if (schema instanceof ZodObject) return schema.meta();
+	return void 0;
+}
+async function getSchemaMetadata(schema) {
+	const vendor = schema["~standard"]?.vendor;
+	if (vendor === "zod") return getZodMetadata(schema);
+	return void 0;
+}
+async function convertSchemaWithComponents(schema, componentCollector) {
+	if (!schema) return void 0;
+	const jsonSchema = await convertStandardSchemaToJsonSchema(schema, componentCollector);
+	if (!componentCollector) return jsonSchema;
+	const metadata = await getSchemaMetadata(schema);
+	const schemaId = metadata?.id || jsonSchema?.id;
+	if (schemaId) {
+		const { id,...schemaWithoutId } = jsonSchema;
+		componentCollector.addSchema(schemaId, schemaWithoutId);
+		return componentCollector.getReference(schemaId);
+	}
+	return jsonSchema;
+}
+
+//#endregion
+Object.defineProperty(exports, 'SchemaVendor', {
+  enumerable: true,
+  get: function () {
+    return SchemaVendor;
+  }
+});
+Object.defineProperty(exports, 'StandardSchemaJsonSchema', {
+  enumerable: true,
+  get: function () {
+    return StandardSchemaJsonSchema;
+  }
+});
+Object.defineProperty(exports, 'convertSchemaWithComponents', {
+  enumerable: true,
+  get: function () {
+    return convertSchemaWithComponents;
+  }
+});
+Object.defineProperty(exports, 'convertStandardSchemaToJsonSchema', {
+  enumerable: true,
+  get: function () {
+    return convertStandardSchemaToJsonSchema;
+  }
+});
+Object.defineProperty(exports, 'getSchemaMetadata', {
+  enumerable: true,
+  get: function () {
+    return getSchemaMetadata;
+  }
+});
+Object.defineProperty(exports, 'getZodMetadata', {
+  enumerable: true,
+  get: function () {
+    return getZodMetadata;
+  }
+});
+//# sourceMappingURL=conversion-CrSNoSRa.cjs.map

package/dist/conversion-CrSNoSRa.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversion-CrSNoSRa.cjs","names":["vendor?: string","StandardSchemaJsonSchema: VendorConvertors","jsonSchema: any","componentCollector?: {\n    addSchema(id: string, schema: any): void;\n    getReference(id: string): { $ref: string };\n  }","schema: any","processed: any","schema?: StandardSchemaV1","schema: StandardSchemaV1","schema: StandardSchemaV1 | undefined"],"sources":["../src/conversion.ts"],"sourcesContent":["import type { StandardSchemaV1 } from '@standard-schema/spec';\n\nexport enum SchemaVendor {\n  zod = 'zod',\n  valibot = 'valibot',\n}\n\nexport type VendorConvertor = (schema: any) => Promise<any>;\nexport type VendorConvertors = Record<SchemaVendor, VendorConvertor>;\n\nfunction isSchemaVendor(vendor?: string): vendor is SchemaVendor {\n  if (!vendor) {\n    return false;\n  }\n\n  return Object.values(SchemaVendor).includes(vendor as SchemaVendor);\n}\n\nexport const StandardSchemaJsonSchema: VendorConvertors = {\n  zod: async (schema): Promise<any> => {\n    try {\n      const { z } = await import('zod/v4').catch(() => ({ z: {} }));\n\n      if ('toJSONSchema' in z && typeof z.toJSONSchema === 'function') {\n        return z.toJSONSchema(schema);\n      }\n      const { zodToJsonSchema } = await import('zod-to-json-schema');\n\n      const result = zodToJsonSchema(schema, {\n        removeAdditionalStrategy: 'strict',\n      });\n\n      return result;\n    } catch (error) {\n      // Fallback to basic conversion if zod-to-json-schema is not available\n      console.warn(\n        'zod-to-json-schema not available, using basic conversion',\n        error,\n      );\n      return { type: 'object' };\n    }\n  },\n  valibot: async (schema): Promise<any> => {\n    const { toJsonSchema } = await import('@valibot/to-json-schema');\n    return toJsonSchema(schema as any);\n  },\n};\n\nfunction extractAndConvertDefs(\n  jsonSchema: any,\n  componentCollector?: {\n    addSchema(id: string, schema: any): void;\n    getReference(id: string): { $ref: string };\n  },\n): any {\n  if (!jsonSchema || typeof jsonSchema !== 'object') {\n    return jsonSchema;\n  }\n\n  // Process the schema recursively to update references\n  const processSchema = (schema: any): any => {\n    if (!schema || typeof schema !== 'object') {\n      return schema;\n    }\n\n    // Handle $ref\n    if (schema.$ref && typeof schema.$ref === 'string') {\n      // Convert #/$defs/X to #/components/schemas/X\n      if (schema.$ref.startsWith('#/$defs/')) {\n        const refName = schema.$ref.replace('#/$defs/', '');\n        return componentCollector\n          ? componentCollector.getReference(refName)\n          : schema;\n      }\n      return schema;\n    }\n\n    // Handle arrays\n    if (Array.isArray(schema)) {\n      return schema.map(processSchema);\n    }\n\n    // Process all properties recursively\n    const processed: any = {};\n    for (const [key, value] of Object.entries(schema)) {\n      if (key === '$defs') {\n        // Skip $defs as they've been extracted\n        continue;\n      }\n      processed[key] = processSchema(value);\n    }\n    return processed;\n  };\n\n  // Extract $defs if present\n  if (jsonSchema.$defs && componentCollector) {\n    for (const [defName, defSchema] of Object.entries(jsonSchema.$defs)) {\n      // Process the definition recursively to handle nested $refs\n      const processedDefSchema = processSchema(defSchema);\n      // Add each definition to the component collector\n      componentCollector.addSchema(defName, processedDefSchema);\n    }\n  }\n\n  // Process the schema and remove $defs\n  const { $defs, ...schemaWithoutDefs } = jsonSchema;\n  return processSchema(schemaWithoutDefs);\n}\n\nexport async function convertStandardSchemaToJsonSchema(\n  schema?: StandardSchemaV1,\n  componentCollector?: {\n    addSchema(id: string, schema: any): void;\n    getReference(id: string): { $ref: string };\n  },\n): Promise<any> {\n  if (!schema) {\n    return undefined;\n  }\n\n  const vendor = schema['~standard']?.vendor;\n  if (!isSchemaVendor(vendor)) {\n    throw new Error(\n      `Unsupported or missing vendor \"${vendor}\" for Standard Schema. Supported vendors are: ${Object.keys(StandardSchemaJsonSchema).join(', ')}`,\n    );\n  }\n\n  const toJSONSchema = StandardSchemaJsonSchema[vendor];\n  const jsonSchema = await toJSONSchema(schema);\n\n  // Extract and convert $defs to components\n  return extractAndConvertDefs(jsonSchema, componentCollector);\n}\n\nexport async function getZodMetadata(\n  schema: StandardSchemaV1,\n): Promise<SchemaMeta | undefined> {\n  const { ZodObject } = await import('zod/v4');\n\n  if (schema instanceof ZodObject) {\n    return schema.meta();\n  }\n\n  return undefined;\n}\n\nexport async function getSchemaMetadata(\n  schema: StandardSchemaV1,\n): Promise<SchemaMeta | undefined> {\n  const vendor = schema['~standard']?.vendor;\n\n  if (vendor === 'zod') {\n    return getZodMetadata(schema);\n  }\n\n  return undefined;\n}\n\ninterface SchemaMeta {\n  id?: string;\n}\n\nexport async function convertSchemaWithComponents(\n  schema: StandardSchemaV1 | undefined,\n  componentCollector?: {\n    addSchema(id: string, schema: any): void;\n    getReference(id: string): { $ref: string };\n  },\n): Promise<any> {\n  if (!schema) {\n    return undefined;\n  }\n\n  // Convert to JSON Schema with component collector to handle $defs\n  const jsonSchema = await convertStandardSchemaToJsonSchema(\n    schema,\n    componentCollector,\n  );\n\n  if (!componentCollector) {\n    return jsonSchema;\n  }\n\n  // Check if this schema has metadata with an ID\n  const metadata = await getSchemaMetadata(schema);\n\n  // Also check if the JSON Schema itself has an id field (from Zod's meta)\n  const schemaId = metadata?.id || jsonSchema?.id;\n\n  if (schemaId) {\n    // Remove the id from the schema before adding to components\n    const { id, ...schemaWithoutId } = jsonSchema;\n    // Add this schema to components and return a reference\n    componentCollector.addSchema(schemaId, schemaWithoutId);\n    return componentCollector.getReference(schemaId);\n  }\n\n  return jsonSchema;\n}\n"],"mappings":"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"}

package/dist/conversion-DUyZYTWO.d.mts

@@ -0,0 +1,30 @@
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/conversion.d.ts
+declare enum SchemaVendor {
+  zod = "zod",
+  valibot = "valibot",
+}
+type VendorConvertor = (schema: any) => Promise<any>;
+type VendorConvertors = Record<SchemaVendor, VendorConvertor>;
+declare const StandardSchemaJsonSchema: VendorConvertors;
+declare function convertStandardSchemaToJsonSchema(schema?: StandardSchemaV1, componentCollector?: {
+  addSchema(id: string, schema: any): void;
+  getReference(id: string): {
+    $ref: string;
+  };
+}): Promise<any>;
+declare function getZodMetadata(schema: StandardSchemaV1): Promise<SchemaMeta | undefined>;
+declare function getSchemaMetadata(schema: StandardSchemaV1): Promise<SchemaMeta | undefined>;
+interface SchemaMeta {
+  id?: string;
+}
+declare function convertSchemaWithComponents(schema: StandardSchemaV1 | undefined, componentCollector?: {
+  addSchema(id: string, schema: any): void;
+  getReference(id: string): {
+    $ref: string;
+  };
+}): Promise<any>;
+//#endregion
+export { SchemaVendor, StandardSchemaJsonSchema, VendorConvertor, VendorConvertors, convertSchemaWithComponents, convertStandardSchemaToJsonSchema, getSchemaMetadata, getZodMetadata };
+//# sourceMappingURL=conversion-DUyZYTWO.d.mts.map

package/dist/conversion.cjs

@@ -0,0 +1,8 @@
+const require_conversion = require('./conversion-CrSNoSRa.cjs');
+
+exports.SchemaVendor = require_conversion.SchemaVendor;
+exports.StandardSchemaJsonSchema = require_conversion.StandardSchemaJsonSchema;
+exports.convertSchemaWithComponents = require_conversion.convertSchemaWithComponents;
+exports.convertStandardSchemaToJsonSchema = require_conversion.convertStandardSchemaToJsonSchema;
+exports.getSchemaMetadata = require_conversion.getSchemaMetadata;
+exports.getZodMetadata = require_conversion.getZodMetadata;

package/dist/conversion.d.cts

@@ -0,0 +1,2 @@
+import { SchemaVendor, StandardSchemaJsonSchema, VendorConvertor, VendorConvertors, convertSchemaWithComponents, convertStandardSchemaToJsonSchema, getSchemaMetadata, getZodMetadata } from "./conversion-CH_EmflL.cjs";
+export { SchemaVendor, StandardSchemaJsonSchema, VendorConvertor, VendorConvertors, convertSchemaWithComponents, convertStandardSchemaToJsonSchema, getSchemaMetadata, getZodMetadata };

package/dist/conversion.d.mts

@@ -0,0 +1,2 @@
+import { SchemaVendor, StandardSchemaJsonSchema, VendorConvertor, VendorConvertors, convertSchemaWithComponents, convertStandardSchemaToJsonSchema, getSchemaMetadata, getZodMetadata } from "./conversion-DUyZYTWO.mjs";
+export { SchemaVendor, StandardSchemaJsonSchema, VendorConvertor, VendorConvertors, convertSchemaWithComponents, convertStandardSchemaToJsonSchema, getSchemaMetadata, getZodMetadata };