@outfitter/contracts 0.4.0 → 0.4.2

package/dist/resilience.js

@@ -1,9 +1,81 @@
 // @bun
 import {
-  retry,
-  withTimeout
-} from "./shared/@outfitter/contracts-r21yet6j.js";
-import"./shared/@outfitter/contracts-phjhz5q3.js";
+  TimeoutError
+} from "./shared/@outfitter/contracts-phjhz5q3.js";
+
+// packages/contracts/src/resilience.ts
+import { Result } from "better-result";
+function defaultIsRetryable(error) {
+  return error.category === "network" || error.category === "timeout" || error.category === "rate_limit";
+}
+function calculateDelay(attempt, initialDelayMs, maxDelayMs, backoffMultiplier, jitter) {
+  const baseDelay = initialDelayMs * backoffMultiplier ** (attempt - 1);
+  const cappedDelay = Math.min(baseDelay, maxDelayMs);
+  if (jitter) {
+    const jitterFactor = 0.5 + Math.random();
+    return Math.floor(cappedDelay * jitterFactor);
+  }
+  return cappedDelay;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function retry(fn, options) {
+  const maxAttempts = options?.maxAttempts ?? 3;
+  const initialDelayMs = options?.initialDelayMs ?? 1000;
+  const maxDelayMs = options?.maxDelayMs ?? 30000;
+  const backoffMultiplier = options?.backoffMultiplier ?? 2;
+  const jitter = options?.jitter ?? true;
+  const isRetryable = options?.isRetryable ?? defaultIsRetryable;
+  const onRetry = options?.onRetry;
+  const signal = options?.signal;
+  let lastError;
+  let attempt = 0;
+  while (attempt < maxAttempts) {
+    attempt++;
+    if (signal?.aborted) {
+      return Result.err(lastError ?? new TimeoutError({
+        message: "Operation cancelled",
+        operation: "retry",
+        timeoutMs: 0
+      }));
+    }
+    const result = await fn();
+    if (result.isOk()) {
+      return result;
+    }
+    lastError = result.error;
+    if (attempt >= maxAttempts || !isRetryable(lastError)) {
+      return result;
+    }
+    const delayMs = calculateDelay(attempt, initialDelayMs, maxDelayMs, backoffMultiplier, jitter);
+    if (onRetry) {
+      onRetry(attempt, lastError, delayMs);
+    }
+    await sleep(delayMs);
+  }
+  throw new Error("Unexpected: retry loop completed without returning a result");
+}
+async function withTimeout(fn, options) {
+  const { timeoutMs, operation = "operation" } = options;
+  let timeoutId;
+  const timeoutPromise = new Promise((resolve) => {
+    timeoutId = setTimeout(() => {
+      resolve(Result.err(new TimeoutError({
+        message: `${operation} timed out after ${timeoutMs}ms`,
+        operation,
+        timeoutMs
+      })));
+    }, timeoutMs);
+  });
+  try {
+    return await Promise.race([fn(), timeoutPromise]);
+  } finally {
+    if (timeoutId !== undefined) {
+      clearTimeout(timeoutId);
+    }
+  }
+}
 export {
   withTimeout,
   retry

package/dist/result/index.d.ts

@@ -1,3 +1,3 @@
-import "../shared/@outfitter/contracts-qaccq0gf";
-import { combine2, combine3, expect, orElse, unwrapOrElse } from "../shared/@outfitter/contracts-ar0etwtx";
+import "../shared/@outfitter/contracts-qaccq0gf.js";
+import { combine2, combine3, expect, orElse, unwrapOrElse } from "../shared/@outfitter/contracts-ar0etwtx.js";
 export { unwrapOrElse, orElse, expect, combine3, combine2 };

package/dist/result/index.js

@@ -1,16 +1 @@
-// @bun
-import"../shared/@outfitter/contracts-37gpc56f.js";
-import {
-  combine2,
-  combine3,
-  expect,
-  orElse,
-  unwrapOrElse
-} from "../shared/@outfitter/contracts-zx72gyh1.js";
-export {
-  unwrapOrElse,
-  orElse,
-  expect,
-  combine3,
-  combine2
-};
+export { combine2, combine3, expect, orElse, unwrapOrElse } from "./utilities.js";

package/dist/result/utilities.d.ts

@@ -1,2 +1,2 @@
-import { combine2, combine3, expect, orElse, unwrapOrElse } from "../shared/@outfitter/contracts-ar0etwtx";
+import { combine2, combine3, expect, orElse, unwrapOrElse } from "../shared/@outfitter/contracts-ar0etwtx.js";
 export { unwrapOrElse, orElse, expect, combine3, combine2 };

package/dist/result/utilities.js

@@ -1,11 +1,33 @@
 // @bun
-import {
-  combine2,
-  combine3,
-  expect,
-  orElse,
-  unwrapOrElse
-} from "../shared/@outfitter/contracts-zx72gyh1.js";
+// packages/contracts/src/result/utilities.ts
+import { Result } from "better-result";
+var unwrapOrElse = (result, defaultFn) => {
+  return result.isOk() ? result.value : defaultFn(result.error);
+};
+var orElse = (result, fallback) => {
+  return result.isOk() ? result : fallback;
+};
+var combine2 = (r1, r2) => {
+  if (r1.isErr())
+    return r1;
+  if (r2.isErr())
+    return r2;
+  return Result.ok([r1.value, r2.value]);
+};
+var combine3 = (r1, r2, r3) => {
+  if (r1.isErr())
+    return r1;
+  if (r2.isErr())
+    return r2;
+  if (r3.isErr())
+    return r3;
+  return Result.ok([r1.value, r2.value, r3.value]);
+};
+var expect = (result, message) => {
+  if (result.isOk())
+    return result.value;
+  throw new Error(`${message}: ${String(result.error)}`);
+};
 export {
   unwrapOrElse,
   orElse,

package/dist/schema.d.ts

@@ -1,2 +1,2 @@
-import { JsonSchema, zodToJsonSchema } from "./shared/@outfitter/contracts-hbbxbwkt";
+import { JsonSchema, zodToJsonSchema } from "./shared/@outfitter/contracts-t79engf9.js";
 export { zodToJsonSchema, JsonSchema };

package/dist/schema.js

@@ -1,7 +1,342 @@
 // @bun
-import {
-  zodToJsonSchema
-} from "./shared/@outfitter/contracts-wfht4q2b.js";
+// 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/serialization.d.ts

@@ -1,3 +1,3 @@
-import { SerializeErrorOptions, deserializeError, safeParse, safeStringify, serializeError } from "./shared/@outfitter/contracts-j08e95jw";
-import "./shared/@outfitter/contracts-r35bn9p6";
+import { SerializeErrorOptions, deserializeError, safeParse, safeStringify, serializeError } from "./shared/@outfitter/contracts-31penhwa.js";
+import "./shared/@outfitter/contracts-3gswmhb1.js";
 export { serializeError, safeStringify, safeParse, deserializeError, SerializeErrorOptions };

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

@@ -1,5 +1,5 @@
-import { OutfitterError } from "./contracts-r35bn9p6";
-import { Logger } from "./contracts-2g8r01zf";
+import { OutfitterError } from "./contracts-3gswmhb1.js";
+import { Logger } from "./contracts-rwzqy9rn.js";
 import { Result } from "better-result";
 /**
 * Resolved configuration interface.
@@ -21,20 +21,20 @@ interface ResolvedConfig {
 * ```
 */
 interface HandlerContext {
-	/** Abort signal for cancellation propagation */
-	signal?: AbortSignal;
-	/** Unique request identifier for tracing (UUIDv7) */
-	requestId: string;
-	/** Structured logger with automatic redaction */
-	logger: Logger;
 	/** Resolved configuration values */
 	config?: ResolvedConfig;
-	/** Workspace root path, if detected */
-	workspaceRoot?: string;
 	/** Current working directory */
 	cwd: string;
 	/** Environment variables (filtered, redacted) */
 	env: Record<string, string | undefined>;
+	/** Structured logger with automatic redaction */
+	logger: Logger;
+	/** Unique request identifier for tracing (UUIDv7) */
+	requestId: string;
+	/** Abort signal for cancellation propagation */
+	signal?: AbortSignal;
+	/** Workspace root path, if detected */
+	workspaceRoot?: string;
 }
 /**
 * Handler - transport-agnostic domain logic unit.

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

@@ -1,23 +1,23 @@
-import { HandlerContext, ResolvedConfig } from "./contracts-ss9vjjft";
-import { Logger } from "./contracts-2g8r01zf";
+import { HandlerContext, ResolvedConfig } from "./contracts-0akf2sm6.js";
+import { Logger } from "./contracts-rwzqy9rn.js";
 /**
 * Options for creating a handler context.
 */
 interface CreateContextOptions {
-	/** Logger instance (uses no-op logger if not provided) */
-	logger?: Logger;
 	/** Resolved configuration */
 	config?: ResolvedConfig;
-	/** Abort signal for cancellation */
-	signal?: AbortSignal;
-	/** Explicit request ID (generates UUIDv7 if not provided) */
-	requestId?: string;
-	/** Workspace root path */
-	workspaceRoot?: string;
 	/** Current working directory (defaults to process.cwd()) */
 	cwd?: string;
 	/** Environment variables to include */
 	env?: Record<string, string | undefined>;
+	/** Logger instance (uses no-op logger if not provided) */
+	logger?: Logger;
+	/** Explicit request ID (generates UUIDv7 if not provided) */
+	requestId?: string;
+	/** Abort signal for cancellation */
+	signal?: AbortSignal;
+	/** Workspace root path */
+	workspaceRoot?: string;
 }
 /**
 * Create a HandlerContext for a new request.

package/dist/shared/@outfitter/{contracts-j08e95jw.d.ts → contracts-31penhwa.d.ts}

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

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

@@ -1,13 +1,13 @@
-import { Handler, SyncHandler } from "./contracts-ss9vjjft";
-import { OutfitterError } from "./contracts-r35bn9p6";
+import { Handler, SyncHandler } from "./contracts-0akf2sm6.js";
+import { OutfitterError } from "./contracts-3gswmhb1.js";
 import { z } from "zod";
 declare const ACTION_SURFACES: readonly ["cli", "mcp", "api", "server"];
 type ActionSurface = (typeof ACTION_SURFACES)[number];
 declare const DEFAULT_REGISTRY_SURFACES: readonly ActionSurface[];
 interface ActionCliOption {
-	readonly flags: string;
-	readonly description: string;
 	readonly defaultValue?: string | boolean | string[];
+	readonly description: string;
+	readonly flags: string;
 	readonly required?: boolean;
 }
 interface ActionCliInputContext {
@@ -15,18 +15,18 @@ interface ActionCliInputContext {
 	readonly flags: Record<string, unknown>;
 }
 interface ActionCliSpec<TInput = unknown> {
-	readonly group?: string;
+	readonly aliases?: readonly string[];
 	readonly command?: string;
 	readonly description?: string;
-	readonly aliases?: readonly string[];
-	readonly options?: readonly ActionCliOption[];
+	readonly group?: string;
 	readonly mapInput?: (context: ActionCliInputContext) => TInput;
+	readonly options?: readonly ActionCliOption[];
 }
 interface ActionMcpSpec<TInput = unknown> {
-	readonly tool?: string;
-	readonly description?: string;
 	readonly deferLoading?: boolean;
+	readonly description?: string;
 	readonly mapInput?: (input: unknown) => TInput;
+	readonly tool?: string;
 }
 type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
 interface ActionApiSpec {
@@ -42,15 +42,15 @@ interface ActionSpec<
 	TOutput,
 	TError extends OutfitterError = OutfitterError
 > {
-	readonly id: string;
+	readonly api?: ActionApiSpec;
+	readonly cli?: ActionCliSpec<TInput>;
 	readonly description?: string;
-	readonly surfaces?: readonly ActionSurface[];
-	readonly input: z.ZodType<TInput>;
-	readonly output?: z.ZodType<TOutput>;
 	readonly handler: Handler<TInput, TOutput, TError> | SyncHandler<TInput, TOutput, TError>;
-	readonly cli?: ActionCliSpec<TInput>;
+	readonly id: string;
+	readonly input: z.ZodType<TInput>;
 	readonly mcp?: ActionMcpSpec<TInput>;
-	readonly api?: ActionApiSpec;
+	readonly output?: z.ZodType<TOutput>;
+	readonly surfaces?: readonly ActionSurface[];
 	readonly trpc?: ActionTrpcSpec;
 }
 type AnyActionSpec = ActionSpec<unknown, unknown, OutfitterError>;
@@ -60,9 +60,9 @@ interface ActionRegistry {
 		TOutput,
 		TError extends OutfitterError = OutfitterError
 	>(action: ActionSpec<TInput, TOutput, TError>): ActionRegistry;
-	list(): AnyActionSpec[];
-	get(id: string): AnyActionSpec | undefined;
 	forSurface(surface: ActionSurface): AnyActionSpec[];
+	get(id: string): AnyActionSpec | undefined;
+	list(): AnyActionSpec[];
 }
 declare function defineAction<
 	TInput,