@outfitter/contracts 0.2.0 → 0.4.0

package/dist/shared/@outfitter/{contracts-2f3khqcc.js → contracts-cp5c6dws.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   AssertionError
-} from "./contracts-0cj49e1a.js";
+} from "./contracts-phjhz5q3.js";
 
 // packages/contracts/src/assert/index.ts
 import { Result } from "better-result";

package/dist/shared/@outfitter/{contracts-md2mvvyt.d.ts → contracts-evxky148.d.ts}

@@ -1,4 +1,4 @@
-import { ErrorCategory } from "./contracts-5hr9pdcq";
+import { ErrorCategory } from "./contracts-r35bn9p6";
 /**
 * Backoff strategy configuration options
 */

package/dist/shared/@outfitter/contracts-hbbxbwkt.d.ts

@@ -0,0 +1,60 @@
+import { z } from "zod";
+/**
+* JSON Schema representation.
+*/
+interface JsonSchema {
+	type?: string;
+	properties?: Record<string, JsonSchema>;
+	required?: string[];
+	items?: JsonSchema | JsonSchema[];
+	description?: string;
+	default?: unknown;
+	minimum?: number;
+	maximum?: number;
+	exclusiveMinimum?: number;
+	exclusiveMaximum?: number;
+	minLength?: number;
+	maxLength?: number;
+	pattern?: string;
+	format?: string;
+	enum?: unknown[];
+	const?: unknown;
+	anyOf?: JsonSchema[];
+	oneOf?: JsonSchema[];
+	allOf?: JsonSchema[];
+	not?: JsonSchema | Record<string, never>;
+	$ref?: string;
+	$schema?: string;
+	$defs?: Record<string, JsonSchema>;
+	definitions?: Record<string, JsonSchema>;
+	additionalProperties?: boolean | JsonSchema;
+}
+/**
+* Convert a Zod schema to JSON Schema format.
+*
+* This is a simplified converter that handles common Zod types.
+* For complex schemas, consider using a full zod-to-json-schema library.
+*
+* @param schema - Zod schema to convert
+* @returns JSON Schema representation
+*
+* @example
+* ```typescript
+* const zodSchema = z.object({
+*   name: z.string(),
+*   age: z.number().optional(),
+* });
+*
+* const jsonSchema = zodToJsonSchema(zodSchema);
+* // {
+* //   type: "object",
+* //   properties: {
+* //     name: { type: "string" },
+* //     age: { type: "number" },
+* //   },
+* //   required: ["name"],
+* // }
+* ```
+*/
+declare function zodToJsonSchema(schema: z.ZodType<unknown>): JsonSchema;
+export { JsonSchema, zodToJsonSchema };

package/dist/shared/@outfitter/{contracts-6atxbfag.d.ts → contracts-j08e95jw.d.ts}

@@ -1,4 +1,4 @@
-import { OutfitterError, SerializedError, ValidationError } from "./contracts-5hr9pdcq";
+import { OutfitterError, SerializedError, ValidationError } from "./contracts-r35bn9p6";
 import { Result } from "better-result";
 import { z } from "zod";
 /**

package/dist/shared/@outfitter/{contracts-k0rhaye3.d.ts → contracts-jggbn5tn.d.ts}

@@ -1,4 +1,4 @@
-import { OutfitterError, SerializedError } from "./contracts-5hr9pdcq";
+import { OutfitterError, SerializedError } from "./contracts-r35bn9p6";
 import { Result } from "better-result";
 /**
 * Metadata attached to every response envelope.

package/dist/shared/@outfitter/{contracts-0cj49e1a.js → contracts-phjhz5q3.js}

@@ -80,6 +80,7 @@ var ValidationErrorBase = TaggedError("ValidationError")();
 var AmbiguousErrorBase = TaggedError("AmbiguousError")();
 var AssertionErrorBase = TaggedError("AssertionError")();
 var NotFoundErrorBase = TaggedError("NotFoundError")();
+var AlreadyExistsErrorBase = TaggedError("AlreadyExistsError")();
 var ConflictErrorBase = TaggedError("ConflictError")();
 var PermissionErrorBase = TaggedError("PermissionError")();
 var TimeoutErrorBase = TaggedError("TimeoutError")();
@@ -98,6 +99,12 @@ class ValidationError extends ValidationErrorBase {
       ...context != null && { context }
     });
   }
+  static fromMessage(message, context) {
+    return new ValidationError({
+      message,
+      ...context != null && { context }
+    });
+  }
   exitCode() {
     return getExitCode(this.category);
   }
@@ -151,6 +158,24 @@ class NotFoundError extends NotFoundErrorBase {
   }
 }
 
+class AlreadyExistsError extends AlreadyExistsErrorBase {
+  category = "conflict";
+  static create(resourceType, resourceId, context) {
+    return new AlreadyExistsError({
+      message: `${resourceType} already exists: ${resourceId}`,
+      resourceType,
+      resourceId,
+      ...context != null && { context }
+    });
+  }
+  exitCode() {
+    return getExitCode(this.category);
+  }
+  statusCode() {
+    return getStatusCode(this.category);
+  }
+}
+
 class ConflictError extends ConflictErrorBase {
   category = "conflict";
   static create(message, context) {
@@ -265,4 +290,4 @@ class CancelledError extends CancelledErrorBase {
   }
 }
 
-export { exitCodeMap, statusCodeMap, ERROR_CODES, getExitCode, getStatusCode, ValidationError, AmbiguousError, AssertionError, NotFoundError, ConflictError, PermissionError, TimeoutError, RateLimitError, NetworkError, InternalError, AuthError, CancelledError };
+export { exitCodeMap, statusCodeMap, ERROR_CODES, getExitCode, getStatusCode, ValidationError, AmbiguousError, AssertionError, NotFoundError, AlreadyExistsError, ConflictError, PermissionError, TimeoutError, RateLimitError, NetworkError, InternalError, AuthError, CancelledError };

package/dist/shared/@outfitter/{contracts-pdk7s4t8.js → contracts-r21yet6j.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   TimeoutError
-} from "./contracts-0cj49e1a.js";
+} from "./contracts-phjhz5q3.js";
 
 // packages/contracts/src/resilience.ts
 import { Result } from "better-result";

package/dist/shared/@outfitter/{contracts-5hr9pdcq.d.ts → contracts-r35bn9p6.d.ts}

@@ -129,6 +129,12 @@ declare const NotFoundErrorBase: TaggedErrorClass<"NotFoundError", {
 	resourceId: string;
 	context?: Record<string, unknown>;
 }>;
+declare const AlreadyExistsErrorBase: TaggedErrorClass<"AlreadyExistsError", {
+	message: string;
+	resourceType: string;
+	resourceId: string;
+	context?: Record<string, unknown>;
+}>;
 declare const ConflictErrorBase: TaggedErrorClass<"ConflictError", {
 	message: string;
 	context?: Record<string, unknown>;
@@ -178,6 +184,16 @@ declare class ValidationError extends ValidationErrorBase {
 	readonly category: "validation";
 	/** Create a ValidationError with auto-generated message from field name. */
 	static create(field: string, reason: string, context?: Record<string, unknown>): ValidationError;
+	/**
+	* Create a freeform ValidationError without a specific field.
+	*
+	* Use when the validation failure applies to the input as a whole
+	* rather than a single field (e.g., "Invalid pipeline configuration").
+	*
+	* @param message - Human-readable validation error message
+	* @param context - Optional structured context for debugging
+	*/
+	static fromMessage(message: string, context?: Record<string, unknown>): ValidationError;
 	exitCode(): number;
 	statusCode(): number;
 }
@@ -256,12 +272,55 @@ declare class NotFoundError extends NotFoundErrorBase {
 	statusCode(): number;
 }
 /**
-* State conflict (optimistic locking, concurrent modification).
+* Resource already exists — the inverse of {@link NotFoundError}.
+*
+* Use when a create/write operation fails because the target resource
+* is already present. Carries `resourceType` and `resourceId` to identify
+* what already exists, mirroring {@link NotFoundError}'s structure.
+*
+* Maps to HTTP 409 (Conflict) and exit code 3.
+*
+* @example
+* ```typescript
+* new AlreadyExistsError({
+*   message: "File already exists: notes/meeting.md",
+*   resourceType: "file",
+*   resourceId: "notes/meeting.md",
+* });
+* AlreadyExistsError.create("file", "notes/meeting.md");
+* ```
+*
+* @see ConflictError - For general state conflicts (version mismatch, concurrent modification)
+* @see NotFoundError - The inverse: resource does not exist
+*/
+declare class AlreadyExistsError extends AlreadyExistsErrorBase {
+	readonly category: "conflict";
+	/** Create an AlreadyExistsError with auto-generated message. */
+	static create(resourceType: string, resourceId: string, context?: Record<string, unknown>): AlreadyExistsError;
+	exitCode(): number;
+	statusCode(): number;
+}
+/**
+* State conflict (version mismatch, concurrent modification).
+*
+* Use for general conflicts that don't fit {@link AlreadyExistsError}:
+* optimistic locking failures, concurrent writes, ETag mismatches,
+* or any case where the operation can't proceed due to state divergence.
+*
+* Maps to HTTP 409 (Conflict) and exit code 3.
+*
+* **Choosing the right conflict error:**
+* - Resource already exists? Use {@link AlreadyExistsError}
+* - Version/ETag mismatch? Use {@link ConflictError}
+* - Concurrent modification detected? Use {@link ConflictError}
 *
 * @example
 * ```typescript
 * new ConflictError({ message: "Resource was modified by another process" });
+* ConflictError.create("ETag mismatch: expected abc, got def");
 * ```
+*
+* @see AlreadyExistsError - For "resource already exists" specifically
 */
 declare class ConflictError extends ConflictErrorBase {
 	readonly category: "conflict";
@@ -378,10 +437,10 @@ declare class CancelledError extends CancelledErrorBase {
 /**
 * Union type of all concrete error class instances.
 */
-type AnyKitError = InstanceType<typeof ValidationError> | InstanceType<typeof AmbiguousError> | InstanceType<typeof AssertionError> | InstanceType<typeof NotFoundError> | InstanceType<typeof ConflictError> | InstanceType<typeof PermissionError> | InstanceType<typeof TimeoutError> | InstanceType<typeof RateLimitError> | InstanceType<typeof NetworkError> | InstanceType<typeof InternalError> | InstanceType<typeof AuthError> | InstanceType<typeof CancelledError>;
+type AnyKitError = InstanceType<typeof ValidationError> | InstanceType<typeof AmbiguousError> | InstanceType<typeof AssertionError> | InstanceType<typeof NotFoundError> | InstanceType<typeof AlreadyExistsError> | InstanceType<typeof ConflictError> | InstanceType<typeof PermissionError> | InstanceType<typeof TimeoutError> | InstanceType<typeof RateLimitError> | InstanceType<typeof NetworkError> | InstanceType<typeof InternalError> | InstanceType<typeof AuthError> | InstanceType<typeof CancelledError>;
 /**
 * Type alias for backwards compatibility with handler signatures.
 * Use AnyKitError for the union type.
 */
 type OutfitterError = AnyKitError;
-export { ErrorCategory, exitCodeMap, statusCodeMap, ERROR_CODES, ErrorCode, SerializedError, KitErrorProps, getExitCode, getStatusCode, ValidationError, AmbiguousError, AssertionError, NotFoundError, ConflictError, PermissionError, TimeoutError, RateLimitError, NetworkError, InternalError, AuthError, CancelledError, AnyKitError, OutfitterError };
+export { ErrorCategory, exitCodeMap, statusCodeMap, ERROR_CODES, ErrorCode, SerializedError, KitErrorProps, getExitCode, getStatusCode, ValidationError, AmbiguousError, AssertionError, NotFoundError, AlreadyExistsError, ConflictError, PermissionError, TimeoutError, RateLimitError, NetworkError, InternalError, AuthError, CancelledError, AnyKitError, OutfitterError };

package/dist/shared/@outfitter/{contracts-zyanj0gf.d.ts → contracts-sf1z80yc.d.ts}

@@ -1,5 +1,5 @@
-import { Handler, SyncHandler } from "./contracts-amd2ykn8";
-import { OutfitterError } from "./contracts-5hr9pdcq";
+import { Handler, SyncHandler } from "./contracts-ss9vjjft";
+import { OutfitterError } from "./contracts-r35bn9p6";
 import { z } from "zod";
 declare const ACTION_SURFACES: readonly ["cli", "mcp", "api", "server"];
 type ActionSurface = (typeof ACTION_SURFACES)[number];

package/dist/shared/@outfitter/contracts-sm6vak1a.js

@@ -0,0 +1,14 @@
+// @bun
+// packages/contracts/src/logging.ts
+function createLoggerFactory(adapter) {
+  return {
+    createLogger(config) {
+      return adapter.createLogger(config);
+    },
+    async flush() {
+      await adapter.flush?.();
+    }
+  };
+}
+
+export { createLoggerFactory };

package/dist/shared/@outfitter/{contracts-amd2ykn8.d.ts → contracts-ss9vjjft.d.ts}

@@ -1,47 +1,7 @@
-import { OutfitterError } from "./contracts-5hr9pdcq";
+import { OutfitterError } from "./contracts-r35bn9p6";
+import { Logger } from "./contracts-2g8r01zf";
 import { Result } from "better-result";
 /**
-* Logger interface for handler context.
-* Implementations provided by @outfitter/logging.
-*
-* All log methods accept an optional context object that will be merged
-* with any context inherited from parent loggers created via `child()`.
-*/
-interface Logger {
-	trace(message: string, metadata?: Record<string, unknown>): void;
-	trace(metadata: Record<string, unknown>, message: string): never;
-	debug(message: string, metadata?: Record<string, unknown>): void;
-	debug(metadata: Record<string, unknown>, message: string): never;
-	info(message: string, metadata?: Record<string, unknown>): void;
-	info(metadata: Record<string, unknown>, message: string): never;
-	warn(message: string, metadata?: Record<string, unknown>): void;
-	warn(metadata: Record<string, unknown>, message: string): never;
-	error(message: string, metadata?: Record<string, unknown>): void;
-	error(metadata: Record<string, unknown>, message: string): never;
-	fatal(message: string, metadata?: Record<string, unknown>): void;
-	fatal(metadata: Record<string, unknown>, message: string): never;
-	/**
-	* Creates a child logger with additional context.
-	*
-	* Context from the child is merged with the parent's context,
-	* with child context taking precedence for duplicate keys.
-	* Child loggers are composable (can create nested children).
-	*
-	* @param context - Additional context to include in all log messages
-	* @returns A new Logger instance with the merged context
-	*
-	* @example
-	* ```typescript
-	* const requestLogger = ctx.logger.child({ requestId: ctx.requestId });
-	* requestLogger.info("Processing request"); // includes requestId
-	*
-	* const opLogger = requestLogger.child({ operation: "create" });
-	* opLogger.debug("Starting"); // includes requestId + operation
-	* ```
-	*/
-	child(context: Record<string, unknown>): Logger;
-}
-/**
 * Resolved configuration interface.
 * Implementations provided by @outfitter/config.
 */
@@ -108,4 +68,4 @@ type SyncHandler<
 	TOutput,
 	TError extends OutfitterError = OutfitterError
 > = (input: TInput, ctx: HandlerContext) => Result<TOutput, TError>;
-export { Logger, ResolvedConfig, HandlerContext, Handler, SyncHandler };
+export { ResolvedConfig, HandlerContext, Handler, SyncHandler };

package/dist/shared/@outfitter/contracts-wfht4q2b.js

@@ -0,0 +1,341 @@
+// @bun
+// packages/contracts/src/schema.ts
+function zodToJsonSchema(schema) {
+  return convertZodType(schema);
+}
+function getDef(schemaOrDef) {
+  if (!schemaOrDef) {
+    return;
+  }
+  if (schemaOrDef._def) {
+    return schemaOrDef._def;
+  }
+  if (schemaOrDef.def) {
+    return schemaOrDef.def;
+  }
+  return schemaOrDef;
+}
+function getDescription(schema, def) {
+  if (typeof schema?.description === "string") {
+    return schema.description;
+  }
+  if (typeof def?.description === "string") {
+    return def.description;
+  }
+  return;
+}
+function convertZodType(schema) {
+  const def = getDef(schema);
+  if (!def) {
+    return {};
+  }
+  const typeName = def.typeName ?? def.type;
+  let jsonSchema;
+  switch (typeName) {
+    case "ZodString":
+    case "string":
+      jsonSchema = convertString(def);
+      break;
+    case "ZodNumber":
+    case "number":
+      jsonSchema = convertNumber(def);
+      break;
+    case "ZodBoolean":
+    case "boolean":
+      jsonSchema = { type: "boolean" };
+      break;
+    case "ZodNull":
+    case "null":
+      jsonSchema = { type: "null" };
+      break;
+    case "ZodUndefined":
+    case "undefined":
+      jsonSchema = {};
+      break;
+    case "ZodArray":
+    case "array":
+      jsonSchema = convertArray(def);
+      break;
+    case "ZodObject":
+    case "object":
+      jsonSchema = convertObject(def);
+      break;
+    case "ZodOptional":
+    case "optional":
+      jsonSchema = convertZodType(def.innerType);
+      break;
+    case "ZodNullable":
+    case "nullable":
+      jsonSchema = {
+        anyOf: [convertZodType(def.innerType), { type: "null" }]
+      };
+      break;
+    case "ZodDefault":
+    case "default": {
+      const defaultValue = typeof def.defaultValue === "function" ? def.defaultValue() : def.defaultValue;
+      jsonSchema = {
+        ...convertZodType(def.innerType),
+        default: defaultValue
+      };
+      break;
+    }
+    case "ZodEnum":
+    case "enum": {
+      const values = def.values ?? Object.values(def.entries ?? {});
+      jsonSchema = {
+        type: "string",
+        enum: values
+      };
+      break;
+    }
+    case "ZodNativeEnum":
+      jsonSchema = {
+        enum: Object.values(def.values ?? def.entries ?? {})
+      };
+      break;
+    case "ZodLiteral":
+    case "literal": {
+      const literalValues = Array.isArray(def.values) ? def.values : [def.value].filter((value) => value !== undefined);
+      if (literalValues.length > 1) {
+        jsonSchema = {
+          enum: literalValues
+        };
+        break;
+      }
+      jsonSchema = literalValues.length ? {
+        const: literalValues[0]
+      } : {};
+      break;
+    }
+    case "ZodUnion":
+    case "union":
+      jsonSchema = {
+        anyOf: def.options.map(convertZodType)
+      };
+      break;
+    case "ZodIntersection":
+    case "intersection":
+      jsonSchema = {
+        allOf: [convertZodType(def.left), convertZodType(def.right)]
+      };
+      break;
+    case "ZodRecord":
+    case "record":
+      jsonSchema = {
+        type: "object",
+        additionalProperties: def.valueType ? convertZodType(def.valueType) : {}
+      };
+      break;
+    case "ZodTuple":
+    case "tuple":
+      jsonSchema = {
+        type: "array",
+        items: def.items.map(convertZodType)
+      };
+      break;
+    case "ZodAny":
+    case "any":
+      jsonSchema = {};
+      break;
+    case "ZodUnknown":
+    case "unknown":
+      jsonSchema = {};
+      break;
+    case "ZodVoid":
+    case "void":
+      jsonSchema = {};
+      break;
+    case "ZodNever":
+    case "never":
+      jsonSchema = { not: {} };
+      break;
+    case "ZodEffects":
+      jsonSchema = convertZodType(def.schema);
+      break;
+    case "ZodPipeline":
+    case "pipe": {
+      const outputDef = getDef(def.out);
+      const outputType = outputDef?.typeName ?? outputDef?.type;
+      jsonSchema = outputType === "transform" ? convertZodType(def.in) : convertZodType(def.out);
+      break;
+    }
+    case "ZodLazy":
+    case "lazy":
+      jsonSchema = {};
+      break;
+    default:
+      jsonSchema = {};
+      break;
+  }
+  const description = getDescription(schema, def);
+  if (description && !jsonSchema.description) {
+    jsonSchema.description = description;
+  }
+  return jsonSchema;
+}
+function convertString(def) {
+  const schema = { type: "string" };
+  if (def.checks) {
+    for (const check of def.checks) {
+      const normalizedCheck = check?._zod?.def ?? check?.def ?? check;
+      if (normalizedCheck?.kind) {
+        switch (normalizedCheck.kind) {
+          case "min":
+            schema.minLength = normalizedCheck.value;
+            break;
+          case "max":
+            schema.maxLength = normalizedCheck.value;
+            break;
+          case "length":
+            schema.minLength = normalizedCheck.value;
+            schema.maxLength = normalizedCheck.value;
+            break;
+          case "email":
+            schema.pattern = "^[^@]+@[^@]+\\.[^@]+$";
+            break;
+          case "url":
+            schema.pattern = "^https?://";
+            break;
+          case "uuid":
+            schema.pattern = "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$";
+            break;
+          case "regex":
+            schema.pattern = normalizedCheck.regex?.source ?? normalizedCheck.pattern?.source ?? (typeof normalizedCheck.pattern === "string" ? normalizedCheck.pattern : undefined);
+            break;
+          default:
+            break;
+        }
+        continue;
+      }
+      if (!normalizedCheck?.check) {
+        continue;
+      }
+      switch (normalizedCheck.check) {
+        case "min_length":
+          schema.minLength = normalizedCheck.minimum;
+          break;
+        case "max_length":
+          schema.maxLength = normalizedCheck.maximum;
+          break;
+        case "string_format":
+          if (normalizedCheck.pattern) {
+            schema.pattern = typeof normalizedCheck.pattern === "string" ? normalizedCheck.pattern : normalizedCheck.pattern.source;
+          }
+          if (normalizedCheck.format && normalizedCheck.format !== "regex") {
+            schema.format = normalizedCheck.format;
+          }
+          break;
+        default:
+          break;
+      }
+    }
+  }
+  return schema;
+}
+function convertNumber(def) {
+  const schema = { type: "number" };
+  if (def.checks) {
+    for (const check of def.checks) {
+      const normalizedCheck = check?._zod?.def ?? check?.def ?? check;
+      if (normalizedCheck?.kind) {
+        switch (normalizedCheck.kind) {
+          case "min":
+            schema.minimum = normalizedCheck.value;
+            break;
+          case "max":
+            schema.maximum = normalizedCheck.value;
+            break;
+          case "int":
+            schema.type = "integer";
+            break;
+          default:
+            break;
+        }
+        continue;
+      }
+      if (!normalizedCheck?.check) {
+        continue;
+      }
+      switch (normalizedCheck.check) {
+        case "greater_than":
+          if (normalizedCheck.inclusive) {
+            schema.minimum = normalizedCheck.value;
+          } else {
+            schema.exclusiveMinimum = normalizedCheck.value;
+          }
+          break;
+        case "less_than":
+          if (normalizedCheck.inclusive) {
+            schema.maximum = normalizedCheck.value;
+          } else {
+            schema.exclusiveMaximum = normalizedCheck.value;
+          }
+          break;
+        case "number_format":
+          if (normalizedCheck.format === "int" || normalizedCheck.format === "safeint") {
+            schema.type = "integer";
+          }
+          break;
+        default:
+          break;
+      }
+    }
+  }
+  return schema;
+}
+function convertArray(def) {
+  const element = def.element ?? def.type;
+  const schema = {
+    type: "array",
+    items: element ? convertZodType(element) : {}
+  };
+  return schema;
+}
+function isFieldOptional(fieldDef) {
+  if (!(fieldDef?.typeName || fieldDef?.type)) {
+    return false;
+  }
+  const typeName = fieldDef.typeName ?? fieldDef.type;
+  if (typeName === "ZodOptional" || typeName === "ZodDefault" || typeName === "optional" || typeName === "default") {
+    return true;
+  }
+  if (typeName === "ZodEffects") {
+    return isFieldOptional(getDef(fieldDef.schema));
+  }
+  if (typeName === "ZodPipeline" || typeName === "pipe") {
+    const inputOptional = isFieldOptional(getDef(fieldDef.in));
+    const outputDef = getDef(fieldDef.out);
+    const outputType = outputDef?.typeName ?? outputDef?.type;
+    if (outputType === "transform") {
+      return inputOptional;
+    }
+    const outputOptional = isFieldOptional(outputDef);
+    return inputOptional && outputOptional;
+  }
+  if (typeName === "ZodNullable" || typeName === "nullable") {
+    return isFieldOptional(getDef(fieldDef.innerType));
+  }
+  return false;
+}
+function convertObject(def) {
+  const properties = {};
+  const required = [];
+  const shape = typeof def.shape === "function" ? def.shape() : def.shape;
+  for (const [key, value] of Object.entries(shape ?? {})) {
+    properties[key] = convertZodType(value);
+    const fieldDef = getDef(value);
+    if (!isFieldOptional(fieldDef)) {
+      required.push(key);
+    }
+  }
+  const schema = {
+    type: "object",
+    properties
+  };
+  if (required.length > 0) {
+    schema.required = required;
+  }
+  return schema;
+}
+
+export { zodToJsonSchema };

package/dist/validation.d.ts

@@ -1,3 +1,3 @@
-import { createValidator, validateInput } from "./shared/@outfitter/contracts-n9hb6hqt";
-import "./shared/@outfitter/contracts-5hr9pdcq";
+import { createValidator, validateInput } from "./shared/@outfitter/contracts-6j6z9dsd";
+import "./shared/@outfitter/contracts-r35bn9p6";
 export { validateInput, createValidator };