@outfitter/contracts 0.1.0 → 0.3.0

package/dist/shared/@outfitter/{contracts-dbpj0b4k.js → contracts-5k6q4n48.js}

@@ -1,10 +1,8 @@
 // @bun
 import {
-  DEFAULT_PATTERNS,
-  DEFAULT_SENSITIVE_KEYS,
-  createRedactor
-} from "./contracts-s15x2rs4.js";
-import {
+  AlreadyExistsError,
+  AmbiguousError,
+  AssertionError,
   AuthError,
   CancelledError,
   ConflictError,
@@ -15,13 +13,21 @@ import {
   RateLimitError,
   TimeoutError,
   ValidationError
-} from "./contracts-jhsgc85s.js";
+} from "./contracts-phjhz5q3.js";
+import {
+  DEFAULT_PATTERNS,
+  DEFAULT_SENSITIVE_KEYS,
+  createRedactor
+} from "./contracts-s15x2rs4.js";
 
 // packages/contracts/src/serialization.ts
 import { Result } from "better-result";
 var errorRegistry = {
   ValidationError,
+  AmbiguousError,
+  AssertionError,
   NotFoundError,
+  AlreadyExistsError,
   ConflictError,
   PermissionError,
   TimeoutError,
@@ -46,10 +52,22 @@ function extractContext(error) {
     }
     case "NotFoundError": {
       const nfe = error;
+      if (nfe.context !== undefined) {
+        Object.assign(context, nfe.context);
+      }
       context["resourceType"] = nfe.resourceType;
       context["resourceId"] = nfe.resourceId;
       break;
     }
+    case "AlreadyExistsError": {
+      const aee = error;
+      if (aee.context !== undefined) {
+        Object.assign(context, aee.context);
+      }
+      context["resourceType"] = aee.resourceType;
+      context["resourceId"] = aee.resourceId;
+      break;
+    }
     case "TimeoutError": {
       const te = error;
       context["operation"] = te.operation;
@@ -70,6 +88,13 @@ function extractContext(error) {
       }
       break;
     }
+    case "AmbiguousError": {
+      const amb = error;
+      context["candidates"] = amb.candidates;
+      break;
+    }
+    case "AssertionError":
+      break;
     case "ConflictError":
     case "PermissionError":
     case "NetworkError":
@@ -128,12 +153,30 @@ function deserializeError(data) {
       }
       return new ValidationError(props);
     }
-    case "NotFoundError":
-      return new NotFoundError({
+    case "NotFoundError": {
+      const props = {
         message: data.message,
         resourceType: context["resourceType"] ?? "unknown",
         resourceId: context["resourceId"] ?? "unknown"
-      });
+      };
+      const contextWithoutIdentity = Object.fromEntries(Object.entries(context).filter(([key]) => key !== "resourceType" && key !== "resourceId"));
+      if (Object.keys(contextWithoutIdentity).length > 0) {
+        props.context = contextWithoutIdentity;
+      }
+      return new NotFoundError(props);
+    }
+    case "AlreadyExistsError": {
+      const props = {
+        message: data.message,
+        resourceType: context["resourceType"] ?? "unknown",
+        resourceId: context["resourceId"] ?? "unknown"
+      };
+      const contextWithoutIdentity = Object.fromEntries(Object.entries(context).filter(([key]) => key !== "resourceType" && key !== "resourceId"));
+      if (Object.keys(contextWithoutIdentity).length > 0) {
+        props.context = contextWithoutIdentity;
+      }
+      return new AlreadyExistsError(props);
+    }
     case "ConflictError": {
       const props = {
         message: data.message
@@ -196,6 +239,15 @@ function deserializeError(data) {
       }
       return new AuthError(props);
     }
+    case "AmbiguousError":
+      return new AmbiguousError({
+        message: data.message,
+        candidates: context["candidates"] ?? []
+      });
+    case "AssertionError":
+      return new AssertionError({
+        message: data.message
+      });
     case "CancelledError":
       return new CancelledError({
         message: data.message

package/dist/shared/@outfitter/{contracts-g82822x1.d.ts → contracts-6j6z9dsd.d.ts}

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

package/dist/shared/@outfitter/{contracts-y8qg2nvz.js → contracts-agmt8915.js}

@@ -1,12 +1,12 @@
 // @bun
 // packages/contracts/src/context.ts
 var noopLogger = {
-  trace: () => {},
-  debug: () => {},
-  info: () => {},
-  warn: () => {},
-  error: () => {},
-  fatal: () => {},
+  trace: (..._args) => {},
+  debug: (..._args) => {},
+  info: (..._args) => {},
+  warn: (..._args) => {},
+  error: (..._args) => {},
+  fatal: (..._args) => {},
   child: () => noopLogger
 };
 function createContext(options) {

package/dist/shared/@outfitter/{contracts-109drsem.d.ts → contracts-ar0etwtx.d.ts}

@@ -100,4 +100,26 @@ declare const combine3: <
 	T3,
 	E
 >(r1: Result<T1, E>, r2: Result<T2, E>, r3: Result<T3, E>) => Result<[T1, T2, T3], E>;
-export { unwrapOrElse, orElse, combine2, combine3 };
+/**
+* Extract value from Ok, or throw with a contextual error message.
+*
+* Like `unwrap()` but with a caller-provided message for better
+* debugging context. Use at system boundaries (CLI adapters, MCP
+* handlers) where you need the value and want a clear error.
+*
+* @param result - The Result to unwrap
+* @param message - Context message prepended to the error
+* @returns The success value
+* @throws Error with contextual message if Result is Err
+*
+* @example
+* ```typescript
+* const config = expect(loadConfig(), "Failed to load config");
+* // On Err, throws: "Failed to load config: <error details>"
+* ```
+*/
+declare const expect: <
+	T,
+	E
+>(result: Result<T, E>, message: string) => T;
+export { unwrapOrElse, orElse, combine2, combine3, expect };

package/dist/shared/@outfitter/{contracts-37891j7e.d.ts → contracts-bdwg55c5.d.ts}

@@ -1,4 +1,4 @@
-import { OutfitterError, TimeoutError } from "./contracts-ev4a68sg";
+import { OutfitterError, TimeoutError } from "./contracts-r35bn9p6";
 import { Result } from "better-result";
 /**
 * Options for retry behavior.

package/dist/shared/@outfitter/{contracts-chnm7kvm.js → contracts-btg89x4h.js}

@@ -1,13 +1,13 @@
 // @bun
 import {
   serializeError
-} from "./contracts-dbpj0b4k.js";
+} from "./contracts-5k6q4n48.js";
 import {
   generateRequestId
-} from "./contracts-y8qg2nvz.js";
+} from "./contracts-agmt8915.js";
 import {
   statusCodeMap
-} from "./contracts-jhsgc85s.js";
+} from "./contracts-phjhz5q3.js";
 
 // packages/contracts/src/envelope.ts
 function buildMeta(overrides) {

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

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

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

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

package/dist/shared/@outfitter/{contracts-0taqjz0a.d.ts → contracts-j08e95jw.d.ts}

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

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

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

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

@@ -30,7 +30,8 @@ var ERROR_CODES = {
     FIELD_REQUIRED: 1001,
     INVALID_FORMAT: 1002,
     OUT_OF_RANGE: 1003,
-    TYPE_MISMATCH: 1004
+    TYPE_MISMATCH: 1004,
+    AMBIGUOUS_MATCH: 1005
   },
   not_found: {
     RESOURCE_NOT_FOUND: 2001,
@@ -76,8 +77,10 @@ function getStatusCode(category) {
   return statusCodeMap[category];
 }
 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")();
@@ -89,6 +92,36 @@ var CancelledErrorBase = TaggedError("CancelledError")();
 
 class ValidationError extends ValidationErrorBase {
   category = "validation";
+  static create(field, reason, context) {
+    return new ValidationError({
+      message: `${field}: ${reason}`,
+      field,
+      ...context != null && { context }
+    });
+  }
+  static fromMessage(message, context) {
+    return new ValidationError({
+      message,
+      ...context != null && { context }
+    });
+  }
+  exitCode() {
+    return getExitCode(this.category);
+  }
+  statusCode() {
+    return getStatusCode(this.category);
+  }
+}
+
+class AmbiguousError extends AmbiguousErrorBase {
+  category = "validation";
+  static create(what, candidates, context) {
+    return new AmbiguousError({
+      message: `Ambiguous ${what}: ${candidates.length} matches found`,
+      candidates,
+      ...context != null && { context }
+    });
+  }
   exitCode() {
     return getExitCode(this.category);
   }
@@ -109,6 +142,32 @@ class AssertionError extends AssertionErrorBase {
 
 class NotFoundError extends NotFoundErrorBase {
   category = "not_found";
+  static create(resourceType, resourceId, context) {
+    return new NotFoundError({
+      message: `${resourceType} not found: ${resourceId}`,
+      resourceType,
+      resourceId,
+      ...context != null && { context }
+    });
+  }
+  exitCode() {
+    return getExitCode(this.category);
+  }
+  statusCode() {
+    return getStatusCode(this.category);
+  }
+}
+
+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);
   }
@@ -119,6 +178,9 @@ class NotFoundError extends NotFoundErrorBase {
 
 class ConflictError extends ConflictErrorBase {
   category = "conflict";
+  static create(message, context) {
+    return new ConflictError({ message, ...context != null && { context } });
+  }
   exitCode() {
     return getExitCode(this.category);
   }
@@ -129,6 +191,12 @@ class ConflictError extends ConflictErrorBase {
 
 class PermissionError extends PermissionErrorBase {
   category = "permission";
+  static create(message, context) {
+    return new PermissionError({
+      message,
+      ...context != null && { context }
+    });
+  }
   exitCode() {
     return getExitCode(this.category);
   }
@@ -139,6 +207,13 @@ class PermissionError extends PermissionErrorBase {
 
 class TimeoutError extends TimeoutErrorBase {
   category = "timeout";
+  static create(operation, timeoutMs) {
+    return new TimeoutError({
+      message: `${operation} timed out after ${timeoutMs}ms`,
+      operation,
+      timeoutMs
+    });
+  }
   exitCode() {
     return getExitCode(this.category);
   }
@@ -149,6 +224,12 @@ class TimeoutError extends TimeoutErrorBase {
 
 class RateLimitError extends RateLimitErrorBase {
   category = "rate_limit";
+  static create(message, retryAfterSeconds) {
+    return new RateLimitError({
+      message,
+      ...retryAfterSeconds != null && { retryAfterSeconds }
+    });
+  }
   exitCode() {
     return getExitCode(this.category);
   }
@@ -159,6 +240,9 @@ class RateLimitError extends RateLimitErrorBase {
 
 class NetworkError extends NetworkErrorBase {
   category = "network";
+  static create(message, context) {
+    return new NetworkError({ message, ...context != null && { context } });
+  }
   exitCode() {
     return getExitCode(this.category);
   }
@@ -169,6 +253,9 @@ class NetworkError extends NetworkErrorBase {
 
 class InternalError extends InternalErrorBase {
   category = "internal";
+  static create(message, context) {
+    return new InternalError({ message, ...context != null && { context } });
+  }
   exitCode() {
     return getExitCode(this.category);
   }
@@ -179,6 +266,9 @@ class InternalError extends InternalErrorBase {
 
 class AuthError extends AuthErrorBase {
   category = "auth";
+  static create(message, reason) {
+    return new AuthError({ message, ...reason != null && { reason } });
+  }
   exitCode() {
     return getExitCode(this.category);
   }
@@ -189,6 +279,9 @@ class AuthError extends AuthErrorBase {
 
 class CancelledError extends CancelledErrorBase {
   category = "cancelled";
+  static create(message) {
+    return new CancelledError({ message });
+  }
   exitCode() {
     return getExitCode(this.category);
   }
@@ -197,4 +290,4 @@ class CancelledError extends CancelledErrorBase {
   }
 }
 
-export { exitCodeMap, statusCodeMap, ERROR_CODES, getExitCode, getStatusCode, ValidationError, 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-aq745b7n.js → contracts-r21yet6j.js}

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

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

@@ -40,6 +40,7 @@ declare const ERROR_CODES: {
 		readonly INVALID_FORMAT: 1002;
 		readonly OUT_OF_RANGE: 1003;
 		readonly TYPE_MISMATCH: 1004;
+		readonly AMBIGUOUS_MATCH: 1005;
 	};
 	readonly not_found: {
 		readonly RESOURCE_NOT_FOUND: 2001;
@@ -112,6 +113,12 @@ declare function getStatusCode(category: ErrorCategory): number;
 declare const ValidationErrorBase: TaggedErrorClass<"ValidationError", {
 	message: string;
 	field?: string;
+	context?: Record<string, unknown>;
+}>;
+declare const AmbiguousErrorBase: TaggedErrorClass<"AmbiguousError", {
+	message: string;
+	candidates: string[];
+	context?: Record<string, unknown>;
 }>;
 declare const AssertionErrorBase: TaggedErrorClass<"AssertionError", {
 	message: string;
@@ -120,6 +127,13 @@ declare const NotFoundErrorBase: TaggedErrorClass<"NotFoundError", {
 	message: string;
 	resourceType: string;
 	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;
@@ -159,10 +173,50 @@ declare const CancelledErrorBase: TaggedErrorClass<"CancelledError", {
 * @example
 * ```typescript
 * new ValidationError({ message: "Email format invalid", field: "email" });
+* new ValidationError({
+*   message: "Value out of range",
+*   field: "age",
+*   context: { min: 0, max: 150, received: -1 },
+* });
 * ```
 */
 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;
+}
+/**
+* Multiple matches found — user must disambiguate.
+*
+* Used in search/resolution systems where partial input matches
+* multiple candidates. Carries the candidate list so transport
+* layers can prompt disambiguation.
+*
+* @example
+* ```typescript
+* new AmbiguousError({
+*   message: "Multiple headings match 'Intro'",
+*   candidates: ["Introduction", "Intro to APIs"],
+* });
+* AmbiguousError.create("heading", ["Introduction", "Intro to APIs"]);
+* ```
+*/
+declare class AmbiguousError extends AmbiguousErrorBase {
+	readonly category: "validation";
+	/** Create an AmbiguousError with auto-generated message. */
+	static create(what: string, candidates: string[], context?: Record<string, unknown>): AmbiguousError;
 	exitCode(): number;
 	statusCode(): number;
 }
@@ -202,23 +256,76 @@ declare class AssertionError extends AssertionErrorBase {
 * @example
 * ```typescript
 * new NotFoundError({ message: "note not found: abc123", resourceType: "note", resourceId: "abc123" });
+* new NotFoundError({
+*   message: "Heading not found",
+*   resourceType: "heading",
+*   resourceId: "h:Intro",
+*   context: { availableHeadings: ["Introduction", "Getting Started"] },
+* });
 * ```
 */
 declare class NotFoundError extends NotFoundErrorBase {
 	readonly category: "not_found";
+	/** Create a NotFoundError with auto-generated message. */
+	static create(resourceType: string, resourceId: string, context?: Record<string, unknown>): NotFoundError;
 	exitCode(): number;
 	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";
+	/** Create a ConflictError with optional context. */
+	static create(message: string, context?: Record<string, unknown>): ConflictError;
 	exitCode(): number;
 	statusCode(): number;
 }
@@ -232,6 +339,8 @@ declare class ConflictError extends ConflictErrorBase {
 */
 declare class PermissionError extends PermissionErrorBase {
 	readonly category: "permission";
+	/** Create a PermissionError with optional context. */
+	static create(message: string, context?: Record<string, unknown>): PermissionError;
 	exitCode(): number;
 	statusCode(): number;
 }
@@ -245,6 +354,8 @@ declare class PermissionError extends PermissionErrorBase {
 */
 declare class TimeoutError extends TimeoutErrorBase {
 	readonly category: "timeout";
+	/** Create a TimeoutError with auto-generated message. */
+	static create(operation: string, timeoutMs: number): TimeoutError;
 	exitCode(): number;
 	statusCode(): number;
 }
@@ -258,6 +369,8 @@ declare class TimeoutError extends TimeoutErrorBase {
 */
 declare class RateLimitError extends RateLimitErrorBase {
 	readonly category: "rate_limit";
+	/** Create a RateLimitError with optional retry hint. */
+	static create(message: string, retryAfterSeconds?: number): RateLimitError;
 	exitCode(): number;
 	statusCode(): number;
 }
@@ -271,6 +384,8 @@ declare class RateLimitError extends RateLimitErrorBase {
 */
 declare class NetworkError extends NetworkErrorBase {
 	readonly category: "network";
+	/** Create a NetworkError with optional context. */
+	static create(message: string, context?: Record<string, unknown>): NetworkError;
 	exitCode(): number;
 	statusCode(): number;
 }
@@ -284,6 +399,8 @@ declare class NetworkError extends NetworkErrorBase {
 */
 declare class InternalError extends InternalErrorBase {
 	readonly category: "internal";
+	/** Create an InternalError with optional context. */
+	static create(message: string, context?: Record<string, unknown>): InternalError;
 	exitCode(): number;
 	statusCode(): number;
 }
@@ -297,6 +414,8 @@ declare class InternalError extends InternalErrorBase {
 */
 declare class AuthError extends AuthErrorBase {
 	readonly category: "auth";
+	/** Create an AuthError with optional reason. */
+	static create(message: string, reason?: "missing" | "invalid" | "expired"): AuthError;
 	exitCode(): number;
 	statusCode(): number;
 }
@@ -310,16 +429,18 @@ declare class AuthError extends AuthErrorBase {
 */
 declare class CancelledError extends CancelledErrorBase {
 	readonly category: "cancelled";
+	/** Create a CancelledError. */
+	static create(message: string): CancelledError;
 	exitCode(): number;
 	statusCode(): number;
 }
 /**
 * Union type of all concrete error class instances.
 */
-type AnyKitError = InstanceType<typeof ValidationError> | 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, 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-vtrf6rbx.d.ts → contracts-sf1z80yc.d.ts}

@@ -1,5 +1,5 @@
-import { Handler, SyncHandler } from "./contracts-yp3derbe";
-import { OutfitterError } from "./contracts-ev4a68sg";
+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 };