@outfitter/contracts 0.4.2 → 0.5.0

package/dist/shared/@outfitter/{contracts-1waabxbk.d.ts → contracts-drwd9ywk.d.ts}

@@ -1,4 +1,5 @@
-import { HandlerContext, ResolvedConfig } from "./contracts-0akf2sm6.js";
+import { HandlerContext, ResolvedConfig } from "./contracts-zma4mscd.js";
+import { ProgressCallback } from "./contracts-msxdg52h.js";
 import { Logger } from "./contracts-rwzqy9rn.js";
 /**
 * Options for creating a handler context.
@@ -12,6 +13,8 @@ interface CreateContextOptions {
 	env?: Record<string, string | undefined>;
 	/** Logger instance (uses no-op logger if not provided) */
 	logger?: Logger;
+	/** Streaming progress callback (undefined means no streaming) */
+	progress?: ProgressCallback;
 	/** Explicit request ID (generates UUIDv7 if not provided) */
 	requestId?: string;
 	/** Abort signal for cancellation */

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

@@ -0,0 +1,46 @@
+// @bun
+import {
+  ValidationError
+} from "./contracts-vhr2ep6b.js";
+
+// packages/contracts/src/validation.ts
+import { Result } from "better-result";
+function formatZodIssues(issues) {
+  return issues.map((issue) => {
+    const path = issue.path.length > 0 ? issue.path.join(".") : "(root)";
+    return `${path}: ${issue.message}`;
+  }).join("; ");
+}
+function extractField(issues) {
+  const firstIssue = issues[0];
+  if (firstIssue && firstIssue.path.length > 0) {
+    return firstIssue.path.join(".");
+  }
+  return;
+}
+function createValidator(schema) {
+  return (input) => {
+    return validateInput(schema, input);
+  };
+}
+function parseWithSchema(schema, data) {
+  const parseResult = schema.safeParse(data);
+  if (parseResult.success) {
+    return Result.ok(parseResult.data);
+  }
+  const message = formatZodIssues(parseResult.error.issues);
+  const field = extractField(parseResult.error.issues);
+  const errorProps = { message };
+  if (field !== undefined) {
+    errorProps.field = field;
+  }
+  return Result.err(new ValidationError(errorProps));
+}
+function validateInput(schema, input) {
+  return parseWithSchema(schema, input);
+}
+function parseInput(schema, data) {
+  return parseWithSchema(schema, data);
+}
+
+export { formatZodIssues, createValidator, validateInput, parseInput };

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

@@ -0,0 +1,62 @@
+// @bun
+import {
+  getDef
+} from "./contracts-jyhqr766.js";
+
+// packages/contracts/src/internal/schema-converters.ts
+function convertArray(def, convertZodType) {
+  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, convertZodType) {
+  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 { convertArray, isFieldOptional, convertObject };

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

@@ -0,0 +1,18 @@
+// @bun
+// packages/contracts/src/internal/error-base.ts
+import { TaggedError } from "better-result";
+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")();
+var RateLimitErrorBase = TaggedError("RateLimitError")();
+var NetworkErrorBase = TaggedError("NetworkError")();
+var InternalErrorBase = TaggedError("InternalError")();
+var AuthErrorBase = TaggedError("AuthError")();
+var CancelledErrorBase = TaggedError("CancelledError")();
+
+export { ValidationErrorBase, AmbiguousErrorBase, AssertionErrorBase, NotFoundErrorBase, AlreadyExistsErrorBase, ConflictErrorBase, PermissionErrorBase, TimeoutErrorBase, RateLimitErrorBase, NetworkErrorBase, InternalErrorBase, AuthErrorBase, CancelledErrorBase };

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

@@ -0,0 +1,2 @@
+export { deserializeError, serializeError } from "../../internal/error-serialization.js";
+export { safeParse, safeStringify } from "../../internal/safe-json.js";

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

@@ -0,0 +1,25 @@
+// @bun
+// packages/contracts/src/internal/schema-types.ts
+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;
+}
+
+export { getDef, getDescription };

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

@@ -0,0 +1,164 @@
+import { AlreadyExistsErrorBase, AmbiguousErrorBase, AssertionErrorBase, ConflictErrorBase, NotFoundErrorBase, ValidationErrorBase } from "./contracts-qpbv29bg.js";
+/**
+* Input validation failed.
+*
+* @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;
+}
+/**
+* Assertion failed (invariant violation).
+*
+* Used by assertion utilities that return Result types instead of throwing.
+* AssertionError indicates a programming bug — an invariant that should
+* never be violated was broken. These are internal errors, not user input
+* validation failures.
+*
+* **Category rationale**: Uses `internal` (not `validation`) because:
+* - Assertions check **invariants** (programmer assumptions), not user input
+* - A failed assertion means "this should be impossible if the code is correct"
+* - User-facing validation uses {@link ValidationError} with helpful field info
+* - HTTP 500 is correct: this is a server bug, not a client mistake
+*
+* @example
+* ```typescript
+* // In domain logic after validation has passed
+* const result = assertDefined(cachedValue, "Cache should always have value after init");
+* if (result.isErr()) {
+*   return result; // Propagate as internal error
+* }
+* ```
+*
+* @see ValidationError - For user input validation failures (HTTP 400)
+*/
+declare class AssertionError extends AssertionErrorBase {
+	readonly category: "internal";
+	exitCode(): number;
+	statusCode(): number;
+}
+/**
+* Requested resource not found.
+*
+* @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;
+}
+/**
+* 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;
+}
+export { ValidationError, AmbiguousError, AssertionError, NotFoundError, AlreadyExistsError, ConflictError };

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

@@ -0,0 +1,125 @@
+/**
+* Transport-agnostic streaming types for handler progress reporting.
+*
+* {@link StreamEvent} is a discriminated union of events that handlers emit
+* via {@link ProgressCallback} to report progress. Transport adapters (CLI NDJSON,
+* MCP notifications) consume these events without the handler knowing the transport.
+*
+* - {@link StreamStartEvent} — Emitted once at the beginning of a streaming operation
+* - {@link StreamStepEvent} — Emitted when a named phase completes
+* - {@link StreamProgressEvent} — Emitted for incremental progress updates
+*
+* @packageDocumentation
+*/
+/**
+* Emitted once at the beginning of a streaming operation.
+*
+* @example
+* ```typescript
+* ctx.progress?.({
+*   type: "start",
+*   command: "check tsdoc",
+*   ts: new Date().toISOString(),
+* });
+* ```
+*/
+interface StreamStartEvent {
+	/** Discriminator — always `"start"`. */
+	type: "start";
+	/** The command or operation being executed. */
+	command: string;
+	/** ISO-8601 timestamp of when the operation started. */
+	ts: string;
+}
+/**
+* Emitted when a named phase or step completes.
+*
+* @example
+* ```typescript
+* ctx.progress?.({
+*   type: "step",
+*   name: "scanning files",
+*   status: "complete",
+*   duration_ms: 42,
+* });
+* ```
+*/
+interface StreamStepEvent {
+	/** Discriminator — always `"step"`. */
+	type: "step";
+	/** Name of the phase or step. */
+	name: string;
+	/**
+	* Status of the step.
+	*
+	* Common values are `"running"`, `"complete"`, and `"failed"`.
+	* Custom values are still allowed for forward compatibility.
+	*/
+	status: "running" | "complete" | "failed" | (string & {});
+	/** Optional duration of the step in milliseconds. */
+	duration_ms?: number;
+}
+/**
+* Emitted for incremental progress updates (e.g., processing N of M items).
+*
+* @example
+* ```typescript
+* ctx.progress?.({
+*   type: "progress",
+*   current: 5,
+*   total: 10,
+*   message: "Processing file 5 of 10",
+* });
+* ```
+*/
+interface StreamProgressEvent {
+	/** Discriminator — always `"progress"`. */
+	type: "progress";
+	/** Current progress count. */
+	current: number;
+	/** Total expected count. */
+	total: number;
+	/** Optional human-readable progress message. */
+	message?: string;
+}
+/**
+* Discriminated union of all stream event types.
+*
+* Handlers emit these events via `ctx.progress?.()` to report progress
+* without coupling to any specific transport. The `type` field serves
+* as the discriminator for narrowing.
+*
+* @example
+* ```typescript
+* function handleEvent(event: StreamEvent) {
+*   switch (event.type) {
+*     case "start":
+*       console.log(`Starting: ${event.command}`);
+*       break;
+*     case "step":
+*       console.log(`Step: ${event.name} — ${event.status}`);
+*       break;
+*     case "progress":
+*       console.log(`${event.current}/${event.total}`);
+*       break;
+*   }
+* }
+* ```
+*/
+type StreamEvent = StreamStartEvent | StreamStepEvent | StreamProgressEvent;
+/**
+* Callback type for reporting streaming progress events.
+*
+* Transport adapters provide this callback to handlers via `ctx.progress`.
+* When `progress` is `undefined` on {@link HandlerContext}, the handler
+* does not stream — it simply returns its final result.
+*
+* @example
+* ```typescript
+* const progress: ProgressCallback = (event) => {
+*   process.stdout.write(JSON.stringify(event) + "\n");
+* };
+* ```
+*/
+type ProgressCallback = (event: StreamEvent) => void;
+export { StreamStartEvent, StreamStepEvent, StreamProgressEvent, StreamEvent, ProgressCallback };

package/dist/shared/@outfitter/{contracts-95cc3y06.d.ts → contracts-mt027fqj.d.ts}

@@ -1,4 +1,5 @@
-import { OutfitterError, TimeoutError } from "./contracts-3gswmhb1.js";
+import { OutfitterError } from "./contracts-7a0xmwbg.js";
+import { TimeoutError } from "./contracts-735ecmbq.js";
 import { Result } from "better-result";
 /**
 * Options for retry behavior.

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

@@ -0,0 +1,174 @@
+/**
+* Error taxonomy: categories, code maps, metadata, and lookup functions.
+*
+* @internal
+*/
+/**
+* Error categories for classification, exit codes, and HTTP status mapping.
+*
+* Used for:
+* - CLI exit code determination
+* - HTTP status code mapping
+* - Error grouping in logs and metrics
+* - Client retry decisions (transient vs permanent)
+*/
+type ErrorCategory = "validation" | "not_found" | "conflict" | "permission" | "timeout" | "rate_limit" | "network" | "internal" | "auth" | "cancelled";
+/**
+* Maps error category to CLI exit code.
+* Non-zero exit indicates error; specific values for script automation.
+*/
+declare const exitCodeMap: Record<ErrorCategory, number>;
+/**
+* Maps error category to HTTP status code.
+* Used by MCP servers and API responses.
+*/
+declare const statusCodeMap: Record<ErrorCategory, number>;
+/**
+* Maps error category to JSON-RPC 2.0 error code (for MCP protocol compliance).
+*
+* Standard protocol codes (-32600 series) for direct mappings:
+* - validation -> -32602 (Invalid params)
+* - internal -> -32603 (Internal error)
+*
+* Implementation-defined server error codes (-32000 to -32099) for domain categories:
+* - auth -> -32000
+* - timeout -> -32001
+* - conflict -> -32002
+* - permission -> -32003
+* - rate_limit -> -32004
+* - network -> -32005
+* - cancelled -> -32006
+* - not_found -> -32007
+*/
+declare const jsonRpcCodeMap: Record<ErrorCategory, number>;
+/**
+* Maps error category to whether the error is safe to retry (for agent safety).
+*
+* Transient errors (timeout, rate_limit, network) are retryable — they may
+* succeed on a subsequent attempt. Permanent errors require human intervention
+* or input correction before retrying would help.
+*/
+declare const retryableMap: Record<ErrorCategory, boolean>;
+/**
+* Unified metadata for an error category.
+*
+* Combines exit code, HTTP status, JSON-RPC code, and retryable flag
+* into a single lookup for transport adapters and agent tooling.
+*/
+interface ErrorCategoryMeta {
+	exitCode: number;
+	statusCode: number;
+	jsonRpcCode: number;
+	retryable: boolean;
+}
+/**
+* Get unified metadata for an error category.
+*
+* Returns exit code, HTTP status code, JSON-RPC error code, and retryable
+* flag in a single object. Useful for transport adapters that need all
+* metadata at once.
+*
+* @example
+* ```typescript
+* const meta = errorCategoryMeta("validation");
+* // { exitCode: 1, statusCode: 400, jsonRpcCode: -32602, retryable: false }
+*
+* const meta = errorCategoryMeta("timeout");
+* // { exitCode: 5, statusCode: 504, jsonRpcCode: -32001, retryable: true }
+* ```
+*/
+declare function errorCategoryMeta(category: ErrorCategory): ErrorCategoryMeta;
+/**
+* Numeric error codes for granular error identification.
+*
+* Ranges by category:
+* - validation: 1000-1999
+* - not_found: 2000-2999
+* - conflict: 3000-3999
+* - permission: 4000-4999
+* - timeout: 5000-5999
+* - rate_limit: 6000-6999
+* - network: 7000-7999
+* - internal: 8000-8999
+* - auth: 9000-9999
+* - cancelled: 10000-10999
+*/
+declare const ERROR_CODES: {
+	readonly validation: {
+		readonly FIELD_REQUIRED: 1001;
+		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;
+		readonly FILE_NOT_FOUND: 2002;
+	};
+	readonly conflict: {
+		readonly ALREADY_EXISTS: 3001;
+		readonly VERSION_MISMATCH: 3002;
+	};
+	readonly permission: {
+		readonly FORBIDDEN: 4001;
+		readonly INSUFFICIENT_RIGHTS: 4002;
+	};
+	readonly timeout: {
+		readonly OPERATION_TIMEOUT: 5001;
+		readonly CONNECTION_TIMEOUT: 5002;
+	};
+	readonly rate_limit: {
+		readonly QUOTA_EXCEEDED: 6001;
+		readonly THROTTLED: 6002;
+	};
+	readonly network: {
+		readonly CONNECTION_REFUSED: 7001;
+		readonly DNS_FAILED: 7002;
+	};
+	readonly internal: {
+		readonly UNEXPECTED_STATE: 8001;
+		readonly ASSERTION_FAILED: 8002;
+	};
+	readonly auth: {
+		readonly INVALID_TOKEN: 9001;
+		readonly EXPIRED_TOKEN: 9002;
+	};
+	readonly cancelled: {
+		readonly USER_CANCELLED: 10_001;
+		readonly SIGNAL_RECEIVED: 10_002;
+	};
+};
+/**
+* Union type of all numeric error codes.
+* Useful for type-safe error code handling.
+*/
+type ErrorCode = (typeof ERROR_CODES)[keyof typeof ERROR_CODES][keyof (typeof ERROR_CODES)[keyof typeof ERROR_CODES]];
+/**
+* Serialized error format for JSON transport.
+*/
+interface SerializedError {
+	_tag: string;
+	category: ErrorCategory;
+	context?: Record<string, unknown>;
+	message: string;
+}
+/**
+* Base interface for OutfitterError properties.
+* All concrete error classes must include these fields.
+*
+* @deprecated Use `OutfitterError` (or concrete error class constructor props) instead. This alias will be removed in v1.0.
+*/
+interface KitErrorProps {
+	category: ErrorCategory;
+	context?: Record<string, unknown>;
+	message: string;
+}
+/**
+* Get CLI exit code for an error category.
+*/
+declare function getExitCode(category: ErrorCategory): number;
+/**
+* Get HTTP status code for an error category.
+*/
+declare function getStatusCode(category: ErrorCategory): number;
+export { ErrorCategory, exitCodeMap, statusCodeMap, jsonRpcCodeMap, retryableMap, ErrorCategoryMeta, errorCategoryMeta, ERROR_CODES, ErrorCode, SerializedError, KitErrorProps, getExitCode, getStatusCode };

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

@@ -0,0 +1,46 @@
+import { OutfitterError } from "./contracts-7a0xmwbg.js";
+import { SerializedError } from "./contracts-njb2art4.js";
+/**
+* Options for error serialization.
+*/
+interface SerializeErrorOptions {
+	/** Include stack trace (default: false in production, true otherwise). */
+	includeStack?: boolean;
+}
+/**
+* Serialize a OutfitterError to JSON-safe format.
+*
+* Strips stack traces in production, preserves in development.
+* Automatically redacts sensitive values from context.
+*
+* @param error - The error to serialize
+* @param options - Serialization options
+* @param isProduction - Whether the environment is production. When omitted, falls back to
+*   `process.env["NODE_ENV"] === "production"` for safe-by-default stack stripping.
+* @returns JSON-safe serialized error
+*
+* @example
+* ```typescript
+* const serialized = serializeError(new NotFoundError("note", "abc123"));
+* // { _tag: "NotFoundError", category: "not_found", message: "note not found: abc123", context: { resourceType: "note", resourceId: "abc123" } }
+* ```
+*/
+declare function serializeError(error: OutfitterError, options?: SerializeErrorOptions, isProduction?: boolean): SerializedError;
+/**
+* Deserialize error from JSON (e.g., from MCP response).
+*
+* Returns a typed OutfitterError subclass based on _tag.
+*
+* @param data - Serialized error data
+* @returns Reconstructed OutfitterError instance
+*
+* @example
+* ```typescript
+* const error = deserializeError(jsonData);
+* if (error._tag === "NotFoundError") {
+*   // TypeScript knows error.resourceType exists
+* }
+* ```
+*/
+declare function deserializeError(data: SerializedError): OutfitterError;
+export { SerializeErrorOptions, serializeError, deserializeError };