@outfitter/contracts 0.4.1 → 0.4.2

package/README.md

@@ -34,7 +34,10 @@ import {
 } from "@outfitter/contracts";
 
 // Define a handler
-const getNote: Handler<{ id: string }, Note, NotFoundError> = async (input, ctx) => {
+const getNote: Handler<{ id: string }, Note, NotFoundError> = async (
+  input,
+  ctx
+) => {
   const note = await db.notes.find(input.id);
   if (!note) return Result.err(NotFoundError.create("note", input.id));
   return Result.ok(note);
@@ -49,21 +52,21 @@ const result = await getNote({ id: "abc123" }, ctx);
 
 All error classes provide a static `create()` factory method that generates a consistent message from structured parameters. Use `create()` for structured errors and the constructor for custom messages.
 
-| Error Class | `create()` Signature | Generated Message |
-|---|---|---|
-| `ValidationError` | `create(field, reason, context?)` | `"email: format invalid"` |
-| `ValidationError` | `fromMessage(message, context?)` | *(your message as-is)* |
-| `AmbiguousError` | `create(what, candidates, context?)` | `"Ambiguous heading: 2 matches found"` |
-| `NotFoundError` | `create(resourceType, resourceId, context?)` | `"note not found: abc123"` |
+| Error Class          | `create()` Signature                         | Generated Message                         |
+| -------------------- | -------------------------------------------- | ----------------------------------------- |
+| `ValidationError`    | `create(field, reason, context?)`            | `"email: format invalid"`                 |
+| `ValidationError`    | `fromMessage(message, context?)`             | _(your message as-is)_                    |
+| `AmbiguousError`     | `create(what, candidates, context?)`         | `"Ambiguous heading: 2 matches found"`    |
+| `NotFoundError`      | `create(resourceType, resourceId, context?)` | `"note not found: abc123"`                |
 | `AlreadyExistsError` | `create(resourceType, resourceId, context?)` | `"file already exists: notes/meeting.md"` |
-| `ConflictError` | `create(message, context?)` | *(your message as-is)* |
-| `PermissionError` | `create(message, context?)` | *(your message as-is)* |
-| `TimeoutError` | `create(operation, timeoutMs)` | `"database query timed out after 5000ms"` |
-| `RateLimitError` | `create(message, retryAfterSeconds?)` | *(your message as-is)* |
-| `NetworkError` | `create(message, context?)` | *(your message as-is)* |
-| `InternalError` | `create(message, context?)` | *(your message as-is)* |
-| `AuthError` | `create(message, reason?)` | *(your message as-is)* |
-| `CancelledError` | `create(message)` | *(your message as-is)* |
+| `ConflictError`      | `create(message, context?)`                  | _(your message as-is)_                    |
+| `PermissionError`    | `create(message, context?)`                  | _(your message as-is)_                    |
+| `TimeoutError`       | `create(operation, timeoutMs)`               | `"database query timed out after 5000ms"` |
+| `RateLimitError`     | `create(message, retryAfterSeconds?)`        | _(your message as-is)_                    |
+| `NetworkError`       | `create(message, context?)`                  | _(your message as-is)_                    |
+| `InternalError`      | `create(message, context?)`                  | _(your message as-is)_                    |
+| `AuthError`          | `create(message, reason?)`                   | _(your message as-is)_                    |
+| `CancelledError`     | `create(message)`                            | _(your message as-is)_                    |
 
 ### Message Casing
 

package/dist/actions.js

@@ -1,10 +1,29 @@
 // @bun
-import {
-  ACTION_SURFACES,
-  DEFAULT_REGISTRY_SURFACES,
-  createActionRegistry,
-  defineAction
-} from "./shared/@outfitter/contracts-q0v44kef.js";
+// packages/contracts/src/actions.ts
+var ACTION_SURFACES = ["cli", "mcp", "api", "server"];
+var DEFAULT_REGISTRY_SURFACES = ACTION_SURFACES;
+function defineAction(action) {
+  return action;
+}
+function createActionRegistry() {
+  const actions = new Map;
+  return {
+    add(action) {
+      actions.set(action.id, action);
+      return this;
+    },
+    list() {
+      return Array.from(actions.values());
+    },
+    get(id) {
+      return actions.get(id);
+    },
+    forSurface(surface) {
+      const defaults = DEFAULT_REGISTRY_SURFACES;
+      return Array.from(actions.values()).filter((action) => (action.surfaces ?? defaults).includes(surface));
+    }
+  };
+}
 export {
   defineAction,
   createActionRegistry,

package/dist/assert/index.js

@@ -1,11 +1,33 @@
 // @bun
 import {
-  assertDefined,
-  assertMatches,
-  assertNonEmpty,
-  isNonEmptyArray
-} from "../shared/@outfitter/contracts-cp5c6dws.js";
-import"../shared/@outfitter/contracts-phjhz5q3.js";
+  AssertionError
+} from "../shared/@outfitter/contracts-phjhz5q3.js";
+
+// packages/contracts/src/assert/index.ts
+import { Result } from "better-result";
+var isNonEmptyArray = (arr) => {
+  return arr.length > 0;
+};
+var assertDefined = (value, message) => {
+  if (value === null || value === undefined) {
+    return Result.err(new AssertionError({ message: message ?? "Value is null or undefined" }));
+  }
+  return Result.ok(value);
+};
+var assertNonEmpty = (arr, message) => {
+  if (arr.length === 0) {
+    return Result.err(new AssertionError({ message: message ?? "Array is empty" }));
+  }
+  return Result.ok(arr);
+};
+function assertMatches(value, predicate, message) {
+  if (!predicate(value)) {
+    return Result.err(new AssertionError({
+      message: message ?? "Value does not match predicate"
+    }));
+  }
+  return Result.ok(value);
+}
 export {
   isNonEmptyArray,
   assertNonEmpty,

package/dist/capabilities.js

@@ -1,12 +1,61 @@
 // @bun
-import {
-  ACTION_CAPABILITIES,
-  CAPABILITY_SURFACES,
-  DEFAULT_ACTION_SURFACES,
-  capability,
-  capabilityAll,
-  getActionsForSurface
-} from "./shared/@outfitter/contracts-d0tq2adf.js";
+// packages/contracts/src/capabilities.ts
+var CAPABILITY_SURFACES = ["cli", "mcp", "api", "server"];
+var DEFAULT_ACTION_SURFACES = ["cli", "mcp"];
+function capability(surfaces = DEFAULT_ACTION_SURFACES, notes) {
+  return notes ? { surfaces, notes } : { surfaces };
+}
+function capabilityAll(notes) {
+  return capability(CAPABILITY_SURFACES, notes);
+}
+var ACTION_CAPABILITIES = {
+  navigate: capability(),
+  back: capability(),
+  forward: capability(),
+  reload: capability(),
+  tab: capability(),
+  tabs: capability(),
+  newTab: capability(),
+  closeTab: capability(),
+  click: capability(),
+  type: capability(),
+  select: capability(),
+  hover: capability(),
+  focus: capability(["mcp"]),
+  scroll: capability(),
+  press: capability(),
+  fill: capability(),
+  find: capability(),
+  check: capability(),
+  uncheck: capability(),
+  upload: capability(),
+  download: capability(["server"], "Server-only for now"),
+  dialog: capability(),
+  waitFor: capability(["mcp"]),
+  waitForNavigation: capability(["mcp"]),
+  wait: capability(["mcp"]),
+  snap: capability(),
+  screenshot: capability(),
+  html: capability(["mcp"]),
+  text: capability(["mcp"]),
+  marker: capability(),
+  markers: capability(),
+  markerGet: capability(),
+  markerRead: capability(["mcp"]),
+  markerCompare: capability(),
+  markerDelete: capability(),
+  markerResolve: capability(["cli"], "CLI-only for now"),
+  viewport: capability(),
+  colorScheme: capability(),
+  mode: capability(["mcp"]),
+  evaluate: capability(["mcp"]),
+  session: capability(),
+  sessions: capability(["mcp"]),
+  steps: capability()
+};
+function getActionsForSurface(surface) {
+  return Object.entries(ACTION_CAPABILITIES).filter(([, capability2]) => capability2.surfaces.includes(surface)).map(([action]) => action);
+}
 export {
   getActionsForSurface,
   capabilityAll,

package/dist/envelope.js

@@ -1,12 +1,55 @@
 // @bun
 import {
-  toEnvelope,
-  toHttpResponse
-} from "./shared/@outfitter/contracts-85nd53s9.js";
-import"./shared/@outfitter/contracts-3wj7xghe.js";
+  serializeError
+} from "./shared/@outfitter/contracts-5k6q4n48.js";
+import {
+  generateRequestId
+} from "./shared/@outfitter/contracts-agmt8915.js";
+import {
+  statusCodeMap
+} from "./shared/@outfitter/contracts-phjhz5q3.js";
 import"./shared/@outfitter/contracts-s15x2rs4.js";
-import"./shared/@outfitter/contracts-phjhz5q3.js";
-import"./shared/@outfitter/contracts-agmt8915.js";
+
+// packages/contracts/src/envelope.ts
+function buildMeta(overrides) {
+  const meta = {
+    requestId: overrides?.requestId ?? generateRequestId(),
+    timestamp: new Date().toISOString()
+  };
+  if (overrides?.durationMs !== undefined) {
+    meta.durationMs = overrides.durationMs;
+  }
+  return meta;
+}
+function toEnvelope(result, meta) {
+  const envelopeMeta = buildMeta(meta);
+  if (result.isOk()) {
+    return {
+      ok: true,
+      data: result.value,
+      meta: envelopeMeta
+    };
+  }
+  return {
+    ok: false,
+    error: serializeError(result.error),
+    meta: envelopeMeta
+  };
+}
+function toHttpResponse(result) {
+  const envelope = toEnvelope(result);
+  if (envelope.ok) {
+    return {
+      status: 200,
+      body: envelope
+    };
+  }
+  const status = statusCodeMap[envelope.error.category];
+  return {
+    status,
+    body: envelope
+  };
+}
 export {
   toHttpResponse,
   toEnvelope

package/dist/index.d.ts

@@ -1,20 +1,20 @@
 import "./shared/@outfitter/contracts-qaccq0gf.js";
-import { NonEmptyArray, assertDefined, assertMatches, assertNonEmpty, isNonEmptyArray } from "./shared/@outfitter/contracts-mmg0npfk.js";
-import { createValidator, validateInput } from "./shared/@outfitter/contracts-9wtm5nsw.js";
-import { ACTION_CAPABILITIES, ActionCapability, CAPABILITY_SURFACES, CapabilitySurface, DEFAULT_ACTION_SURFACES, capability, capabilityAll, getActionsForSurface } from "./shared/@outfitter/contracts-y8f0m1ze.js";
-import { DEFAULT_PATTERNS, DEFAULT_SENSITIVE_KEYS, RedactionCallback, RedactionEvent, Redactor, RedactorConfig, createRedactor } from "./shared/@outfitter/contracts-9yd4vrjg.js";
-import { BackoffOptions, getBackoffDelay, isRecoverable, isRetryable, shouldRetry } from "./shared/@outfitter/contracts-k71jqd1m.js";
-import { JsonSchema, zodToJsonSchema } from "./shared/@outfitter/contracts-t79engf9.js";
-import { ACTION_SURFACES, ActionApiSpec, ActionCliInputContext, ActionCliOption, ActionCliSpec, ActionMcpSpec, ActionRegistry, ActionSpec, ActionSurface, ActionTrpcSpec, AnyActionSpec, DEFAULT_REGISTRY_SURFACES, HttpMethod, createActionRegistry, defineAction } from "./shared/@outfitter/contracts-56pcsavx.js";
-import { RetryOptions, TimeoutOptions, retry, withTimeout } from "./shared/@outfitter/contracts-95cc3y06.js";
 import { combine2, combine3, expect, orElse, unwrapOrElse } from "./shared/@outfitter/contracts-ar0etwtx.js";
-import { AdapterAuthError, AuthAdapter, CacheAdapter, CacheError, IndexAdapter, IndexError, IndexStats, SearchOptions, SearchResult, StorageAdapter, StorageError } from "./shared/@outfitter/contracts-c2cfj172.js";
-import { Envelope, EnvelopeMeta, ErrorEnvelope, HttpResponse, PaginationMeta, SuccessEnvelope, toEnvelope, toHttpResponse } from "./shared/@outfitter/contracts-e4m948m7.js";
+import { ACTION_SURFACES, ActionApiSpec, ActionCliInputContext, ActionCliOption, ActionCliSpec, ActionMcpSpec, ActionRegistry, ActionSpec, ActionSurface, ActionTrpcSpec, AnyActionSpec, DEFAULT_REGISTRY_SURFACES, HttpMethod, createActionRegistry, defineAction } from "./shared/@outfitter/contracts-56pcsavx.js";
+import { ACTION_CAPABILITIES, ActionCapability, CAPABILITY_SURFACES, CapabilitySurface, DEFAULT_ACTION_SURFACES, capability, capabilityAll, getActionsForSurface } from "./shared/@outfitter/contracts-y8f0m1ze.js";
 import { SerializeErrorOptions, deserializeError, safeParse, safeStringify, serializeError } from "./shared/@outfitter/contracts-31penhwa.js";
+import { JsonSchema, zodToJsonSchema } from "./shared/@outfitter/contracts-t79engf9.js";
 import { CreateContextOptions, createContext, generateRequestId } from "./shared/@outfitter/contracts-1waabxbk.js";
+import { NonEmptyArray, assertDefined, assertMatches, assertNonEmpty, isNonEmptyArray } from "./shared/@outfitter/contracts-mmg0npfk.js";
+import { Envelope, EnvelopeMeta, ErrorEnvelope, HttpResponse, PaginationMeta, SuccessEnvelope, toEnvelope, toHttpResponse } from "./shared/@outfitter/contracts-e4m948m7.js";
+import { AdapterAuthError, AuthAdapter, CacheAdapter, CacheError, IndexAdapter, IndexError, IndexStats, SearchOptions, SearchResult, StorageAdapter, StorageError } from "./shared/@outfitter/contracts-c2cfj172.js";
+import { BackoffOptions, getBackoffDelay, isRecoverable, isRetryable, shouldRetry } from "./shared/@outfitter/contracts-k71jqd1m.js";
+import { RetryOptions, TimeoutOptions, retry, withTimeout } from "./shared/@outfitter/contracts-95cc3y06.js";
+import { createValidator, validateInput } from "./shared/@outfitter/contracts-9wtm5nsw.js";
 import { Handler, HandlerContext, ResolvedConfig, SyncHandler } from "./shared/@outfitter/contracts-0akf2sm6.js";
 import { AlreadyExistsError, AmbiguousError, AnyKitError, AssertionError, AuthError, CancelledError, ConflictError, ERROR_CODES, ErrorCategory, ErrorCode, InternalError, KitErrorProps, NetworkError, NotFoundError, OutfitterError, PermissionError, RateLimitError, SerializedError, TimeoutError, ValidationError, exitCodeMap, getExitCode, getStatusCode, statusCodeMap } from "./shared/@outfitter/contracts-3gswmhb1.js";
 import { LogLevel, LogMetadata, LogMethod, Logger, LoggerAdapter, LoggerFactory, LoggerFactoryConfig, createLoggerFactory } from "./shared/@outfitter/contracts-rwzqy9rn.js";
+import { DEFAULT_PATTERNS, DEFAULT_SENSITIVE_KEYS, RedactionCallback, RedactionEvent, Redactor, RedactorConfig, createRedactor } from "./shared/@outfitter/contracts-9yd4vrjg.js";
 import { TaggedErrorClass } from "better-result";
 import { Result, TaggedError } from "better-result";
 export { zodToJsonSchema, withTimeout, validateInput, unwrapOrElse, toHttpResponse, toEnvelope, statusCodeMap, shouldRetry, serializeError, safeStringify, safeParse, retry, orElse, isRetryable, isRecoverable, isNonEmptyArray, getStatusCode, getExitCode, getBackoffDelay, getActionsForSurface, generateRequestId, expect, exitCodeMap, deserializeError, defineAction, createValidator, createRedactor, createLoggerFactory, createContext, createActionRegistry, combine3, combine2, capabilityAll, capability, assertNonEmpty, assertMatches, assertDefined, ValidationError, TimeoutOptions, TimeoutError, TaggedErrorClass, TaggedError, SyncHandler, SuccessEnvelope, StorageError, StorageAdapter, SerializedError, SerializeErrorOptions, SearchResult, SearchOptions, RetryOptions, Result, ResolvedConfig, RedactorConfig, Redactor, RedactionEvent, RedactionCallback, RateLimitError, PermissionError, PaginationMeta, OutfitterError, NotFoundError, NonEmptyArray, NetworkError, LoggerFactoryConfig, LoggerFactory, LoggerAdapter, Logger, LogMethod, LogMetadata, LogLevel, KitErrorProps, JsonSchema, InternalError, IndexStats, IndexError, IndexAdapter, HttpResponse, HttpMethod, HandlerContext, Handler, ErrorEnvelope, ErrorCode, ErrorCategory, EnvelopeMeta, Envelope, ERROR_CODES, DEFAULT_SENSITIVE_KEYS, DEFAULT_REGISTRY_SURFACES, DEFAULT_PATTERNS, DEFAULT_ACTION_SURFACES, CreateContextOptions, ConflictError, CapabilitySurface, CancelledError, CacheError, CacheAdapter, CAPABILITY_SURFACES, BackoffOptions, AuthError, AuthAdapter, AssertionError, AnyKitError, AnyActionSpec, AmbiguousError, AlreadyExistsError, AdapterAuthError, ActionTrpcSpec, ActionSurface, ActionSpec, ActionRegistry, ActionMcpSpec, ActionCliSpec, ActionCliOption, ActionCliInputContext, ActionCapability, ActionApiSpec, ACTION_SURFACES, ACTION_CAPABILITIES };

package/dist/index.js

@@ -1,153 +1,15 @@
-// @bun
-import"./shared/@outfitter/contracts-37gpc56f.js";
-import {
-  assertDefined,
-  assertMatches,
-  assertNonEmpty,
-  isNonEmptyArray
-} from "./shared/@outfitter/contracts-cp5c6dws.js";
-import {
-  createValidator,
-  validateInput
-} from "./shared/@outfitter/contracts-0snpmkdt.js";
-import {
-  ACTION_CAPABILITIES,
-  CAPABILITY_SURFACES,
-  DEFAULT_ACTION_SURFACES,
-  capability,
-  capabilityAll,
-  getActionsForSurface
-} from "./shared/@outfitter/contracts-d0tq2adf.js";
-import {
-  getBackoffDelay,
-  isRecoverable,
-  isRetryable,
-  shouldRetry
-} from "./shared/@outfitter/contracts-4zaj7ejb.js";
-import {
-  zodToJsonSchema
-} from "./shared/@outfitter/contracts-wfht4q2b.js";
-import {
-  ACTION_SURFACES,
-  DEFAULT_REGISTRY_SURFACES,
-  createActionRegistry,
-  defineAction
-} from "./shared/@outfitter/contracts-q0v44kef.js";
-import {
-  retry,
-  withTimeout
-} from "./shared/@outfitter/contracts-r21yet6j.js";
-import {
-  combine2,
-  combine3,
-  expect,
-  orElse,
-  unwrapOrElse
-} from "./shared/@outfitter/contracts-zx72gyh1.js";
-import {
-  toEnvelope,
-  toHttpResponse
-} from "./shared/@outfitter/contracts-85nd53s9.js";
-import {
-  deserializeError,
-  safeParse,
-  safeStringify,
-  serializeError
-} from "./shared/@outfitter/contracts-3wj7xghe.js";
-import {
-  DEFAULT_PATTERNS,
-  DEFAULT_SENSITIVE_KEYS,
-  createRedactor
-} from "./shared/@outfitter/contracts-s15x2rs4.js";
-import {
-  AlreadyExistsError,
-  AmbiguousError,
-  AssertionError,
-  AuthError,
-  CancelledError,
-  ConflictError,
-  ERROR_CODES,
-  InternalError,
-  NetworkError,
-  NotFoundError,
-  PermissionError,
-  RateLimitError,
-  TimeoutError,
-  ValidationError,
-  exitCodeMap,
-  getExitCode,
-  getStatusCode,
-  statusCodeMap
-} from "./shared/@outfitter/contracts-phjhz5q3.js";
-import {
-  createContext,
-  generateRequestId
-} from "./shared/@outfitter/contracts-agmt8915.js";
-import {
-  createLoggerFactory
-} from "./shared/@outfitter/contracts-sm6vak1a.js";
-
-// packages/contracts/src/index.ts
-import { Result, TaggedError } from "better-result";
-export {
-  zodToJsonSchema,
-  withTimeout,
-  validateInput,
-  unwrapOrElse,
-  toHttpResponse,
-  toEnvelope,
-  statusCodeMap,
-  shouldRetry,
-  serializeError,
-  safeStringify,
-  safeParse,
-  retry,
-  orElse,
-  isRetryable,
-  isRecoverable,
-  isNonEmptyArray,
-  getStatusCode,
-  getExitCode,
-  getBackoffDelay,
-  getActionsForSurface,
-  generateRequestId,
-  expect,
-  exitCodeMap,
-  deserializeError,
-  defineAction,
-  createValidator,
-  createRedactor,
-  createLoggerFactory,
-  createContext,
-  createActionRegistry,
-  combine3,
-  combine2,
-  capabilityAll,
-  capability,
-  assertNonEmpty,
-  assertMatches,
-  assertDefined,
-  ValidationError,
-  TimeoutError,
-  TaggedError,
-  Result,
-  RateLimitError,
-  PermissionError,
-  NotFoundError,
-  NetworkError,
-  InternalError,
-  ERROR_CODES,
-  DEFAULT_SENSITIVE_KEYS,
-  DEFAULT_REGISTRY_SURFACES,
-  DEFAULT_PATTERNS,
-  DEFAULT_ACTION_SURFACES,
-  ConflictError,
-  CancelledError,
-  CAPABILITY_SURFACES,
-  AuthError,
-  AssertionError,
-  AmbiguousError,
-  AlreadyExistsError,
-  ACTION_SURFACES,
-  ACTION_CAPABILITIES
-};
+export { Result, TaggedError } from "better-result";
+export { ACTION_SURFACES, createActionRegistry, DEFAULT_REGISTRY_SURFACES, defineAction } from "./actions.js";
+export { assertDefined, assertMatches, assertNonEmpty, isNonEmptyArray } from "./assert/index.js";
+export { ACTION_CAPABILITIES, CAPABILITY_SURFACES, capability, capabilityAll, DEFAULT_ACTION_SURFACES, getActionsForSurface } from "./capabilities.js";
+export { createContext, generateRequestId } from "./context.js";
+export { toEnvelope, toHttpResponse } from "./envelope.js";
+export { AlreadyExistsError, AmbiguousError, AssertionError, AuthError, CancelledError, ConflictError, ERROR_CODES, exitCodeMap, getExitCode, getStatusCode, InternalError, NetworkError, NotFoundError, PermissionError, RateLimitError, statusCodeMap, TimeoutError, ValidationError } from "./errors.js";
+export { createLoggerFactory } from "./logging.js";
+export { getBackoffDelay, isRecoverable, isRetryable, shouldRetry } from "./recovery.js";
+export { createRedactor, DEFAULT_PATTERNS, DEFAULT_SENSITIVE_KEYS } from "./redactor.js";
+export { retry, withTimeout } from "./resilience.js";
+export { combine2, combine3, expect, orElse, unwrapOrElse } from "./result/index.js";
+export { zodToJsonSchema } from "./schema.js";
+export { deserializeError, safeParse, safeStringify, serializeError } from "./serialization.js";
+export { createValidator, validateInput } from "./validation.js";

package/dist/logging.js

@@ -1,7 +1,15 @@
 // @bun
-import {
-  createLoggerFactory
-} from "./shared/@outfitter/contracts-sm6vak1a.js";
+// packages/contracts/src/logging.ts
+function createLoggerFactory(adapter) {
+  return {
+    createLogger(config) {
+      return adapter.createLogger(config);
+    },
+    async flush() {
+      await adapter.flush?.();
+    }
+  };
+}
 export {
   createLoggerFactory
 };

package/dist/recovery.js

@@ -1,10 +1,53 @@
 // @bun
-import {
-  getBackoffDelay,
-  isRecoverable,
-  isRetryable,
-  shouldRetry
-} from "./shared/@outfitter/contracts-4zaj7ejb.js";
+// packages/contracts/src/recovery.ts
+var RECOVERABLE_CATEGORIES = [
+  "network",
+  "timeout",
+  "rate_limit",
+  "conflict"
+];
+var RETRYABLE_CATEGORIES = ["network", "timeout"];
+var isRecoverable = (error) => {
+  return RECOVERABLE_CATEGORIES.includes(error.category);
+};
+var isRetryable = (error) => {
+  return RETRYABLE_CATEGORIES.includes(error.category);
+};
+var getBackoffDelay = (attempt, options = {}) => {
+  const {
+    baseDelayMs = 100,
+    maxDelayMs = 30000,
+    strategy = "exponential",
+    useJitter = true
+  } = options;
+  let delay;
+  switch (strategy) {
+    case "constant": {
+      delay = baseDelayMs;
+      break;
+    }
+    case "linear": {
+      delay = baseDelayMs * (attempt + 1);
+      break;
+    }
+    default: {
+      delay = baseDelayMs * 2 ** attempt;
+    }
+  }
+  delay = Math.min(delay, maxDelayMs);
+  if (useJitter) {
+    const jitterFactor = 0.1;
+    const jitter = delay * jitterFactor * (Math.random() * 2 - 1);
+    delay = Math.round(delay + jitter);
+  }
+  return Math.min(delay, maxDelayMs);
+};
+var shouldRetry = (error, attempt, maxAttempts = 3) => {
+  if (attempt >= maxAttempts) {
+    return false;
+  }
+  return isRetryable(error);
+};
 export {
   shouldRetry,
   isRetryable,

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.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";