@smoothbricks/lmao 0.1.0

package/src/lib/errors/RetriesExhausted.ts

@@ -0,0 +1,78 @@
+/**
+ * Retries exhausted error - returned when a Blocked error has exceeded max attempts.
+ *
+ * When an Op repeatedly returns `Blocked` and the retry config's `maxAttempts`
+ * is exhausted, the retry layer converts the final failure to `RetriesExhausted`.
+ *
+ * Unlike `Blocked`, this represents a permanent failure that callers must handle
+ * (e.g., compensate, alert, escalate, return error to caller).
+ *
+ * @example
+ * ```typescript
+ * import { defineOpContext, S, Err } from '@smoothbricks/lmao';
+ * import { Blocked } from '@smoothbricks/lmao/errors/Blocked';
+ * import { RetriesExhausted } from '@smoothbricks/lmao/errors/RetriesExhausted';
+ *
+ * const { defineOp } = defineOpContext({
+ *   logSchema: { service: S.category() },
+ *   ctx: { env: null as Env },
+ * });
+ *
+ * // Op that may be blocked by external service
+ * const callPaymentApi = defineOp('callPaymentApi', async (ctx, amount: number) => {
+ *   const health = await checkHealth('payment-api');
+ *   if (!health.available) {
+ *     return new Err(Blocked.service('payment-api'));
+ *   }
+ *   const result = await ctx.deps.http.post('/pay', { amount });
+ *   return ctx.ok(result);
+ * });
+ *
+ * // Caller handles permanent failure after retries exhausted
+ * const result = await trace('checkout', checkoutOp);
+ * if (result.isErr(RetriesExhausted)) {
+ *   ctx.log.error(`Payment failed after ${result.error.attempts} attempts`);
+ *   return ctx.err('PAYMENT_UNAVAILABLE', { service: result.error.reason });
+ * }
+ * ```
+ */
+
+import type { TaggedError } from '../result.js';
+import { type BlockedReason, getBlockedReasonName } from './Blocked.js';
+
+type RetriesExhaustedView = {
+  _tag: 'RetriesExhausted';
+  reason: BlockedReason;
+  attempts: number;
+  maxAttempts: number;
+};
+
+export class RetriesExhausted extends Error implements TaggedError<'RetriesExhausted'> {
+  static readonly _tag = 'RetriesExhausted' as const;
+
+  get _tag(): 'RetriesExhausted' {
+    return 'RetriesExhausted';
+  }
+
+  constructor(
+    /** The original blocked reason */
+    readonly reason: BlockedReason,
+    /** How many attempts were made */
+    readonly attempts: number,
+    /** Max attempts that was configured (the limit that was hit) */
+    readonly maxAttempts: number,
+  ) {
+    super(`RetriesExhausted: ${getBlockedReasonName(reason)} after ${attempts} attempts`);
+    this.name = 'RetriesExhausted';
+  }
+
+  /** Clean output for console.log in Node.js */
+  [Symbol.for('nodejs.util.inspect.custom')](): RetriesExhaustedView {
+    return { _tag: this._tag, reason: this.reason, attempts: this.attempts, maxAttempts: this.maxAttempts };
+  }
+
+  /** Clean output for JSON.stringify */
+  toJSON(): RetriesExhaustedView {
+    return { _tag: this._tag, reason: this.reason, attempts: this.attempts, maxAttempts: this.maxAttempts };
+  }
+}

package/src/lib/errors/Transient.ts

@@ -0,0 +1,168 @@
+/**
+ * TransientError - typed transient error codes with embedded retry policy.
+ *
+ * Use the `Transient()` factory to define transient error codes WITH default retry policy.
+ * Op class checks `instanceof TransientError` and reads `error.policy` for retry config.
+ *
+ * @example
+ * ```typescript
+ * import { Transient, exponentialBackoff, fixedDelay } from '@smoothbricks/lmao/errors/Transient';
+ *
+ * // Define error with default exponential backoff (5 attempts)
+ * const SERVICE_UNAVAILABLE = Transient<{ service: string }>('SERVICE_UNAVAILABLE', exponentialBackoff(5));
+ *
+ * // Define error with fixed delay for rate limiting
+ * const RATE_LIMITED = Transient<{ retryAfter?: number }>('RATE_LIMITED', fixedDelay(3, 5000));
+ *
+ * // Usage - data only, uses default policy
+ * ctx.err(SERVICE_UNAVAILABLE({ service: 'api' }));
+ *
+ * // Override policy for this specific call (e.g., use Retry-After header)
+ * ctx.err(RATE_LIMITED({ retryAfter: 60000 }, fixedDelay(1, 60000)));
+ *
+ * // Op class detects transient and reads policy
+ * if (result.error instanceof TransientError) {
+ *   const { maxAttempts, backoff, baseDelayMs } = result.error.policy;
+ *   // Execute retry loop based on policy
+ * }
+ * ```
+ */
+
+import type { TaggedErrorConstructor } from '../result.js';
+import { CodeError } from './CodeError.js';
+import { mergePolicy, type RetryPolicy } from './retry-policy.js';
+
+/**
+ * Transient error instance - triggers retry in Op class.
+ *
+ * Extends CodeError to inherit code/data pattern while adding:
+ * - `instanceof TransientError` checks for retry classification
+ * - `policy` field carrying merged retry configuration
+ *
+ * @typeParam C - The error code string literal type (also serves as _tag)
+ * @typeParam D - The data payload type
+ */
+export class TransientError<C extends string, D = void> extends CodeError<C, D> {
+  /**
+   * Merged retry policy (defaultPolicy + per-call override).
+   * Op class reads this to configure retry loop.
+   */
+  readonly policy: RetryPolicy;
+
+  constructor(code: C, data: D, policy: RetryPolicy) {
+    super(code, data);
+    this.name = 'TransientError';
+    this.policy = policy;
+  }
+
+  override toJSON() {
+    return {
+      ...super.toJSON(),
+      policy: this.policy,
+    };
+  }
+}
+
+/**
+ * Constructor function for a specific transient error code.
+ * Has static `_tag` for isErr() and `defaultPolicy` for introspection.
+ */
+export interface TransientConstructor<C extends string, D = void> extends TaggedErrorConstructor<TransientError<C, D>> {
+  /** Create transient error with data and optional policy override */
+  (data: D, policyOverride?: Partial<RetryPolicy>): TransientError<C, D>;
+  /** Error code (same as _tag) */
+  readonly _tag: C;
+  /** Default retry policy for this error type */
+  readonly defaultPolicy: RetryPolicy;
+}
+
+/**
+ * Constructor function for transient error codes with no data.
+ */
+export interface TransientConstructorVoid<C extends string> extends TaggedErrorConstructor<TransientError<C, void>> {
+  /** Create transient error with optional policy override */
+  (policyOverride?: Partial<RetryPolicy>): TransientError<C, void>;
+  /** Error code (same as _tag) */
+  readonly _tag: C;
+  /** Default retry policy for this error type */
+  readonly defaultPolicy: RetryPolicy;
+}
+
+type TransientFactoryReturn<C extends string, D> = [unknown] extends [D]
+  ? TransientConstructor<C, D>
+  : undefined extends D
+    ? TransientConstructorVoid<C>
+    : TransientConstructor<C, D>;
+
+/**
+ * Define a typed transient error code with default retry policy.
+ *
+ * Creates errors that extend TransientError, enabling:
+ * - `instanceof TransientError` for retry triggering
+ * - `result.isErr(CODE)` for specific code discrimination
+ * - `error.policy` for retry configuration
+ *
+ * @param code - The error code string (becomes _tag for discrimination)
+ * @param defaultPolicy - Default retry policy for this error type
+ * @returns A constructor function that creates TransientError instances
+ *
+ * @example
+ * ```typescript
+ * // With typed data and exponential backoff
+ * const NETWORK_ERROR = Transient<{ service: string }>('NETWORK_ERROR', exponentialBackoff(5));
+ * ctx.err(NETWORK_ERROR({ service: 'payment-api' }));
+ *
+ * // Without data, linear backoff
+ * const TIMEOUT = Transient('TIMEOUT', linearBackoff(3));
+ * ctx.err(TIMEOUT());
+ *
+ * // Override policy per-call
+ * ctx.err(NETWORK_ERROR({ service: 'api' }, fixedDelay(1, 30000)));
+ *
+ * // Op class handles retry
+ * if (result.error instanceof TransientError) {
+ *   const { policy } = result.error;
+ *   // Retry loop using policy.maxAttempts, policy.backoff, etc.
+ * }
+ * ```
+ */
+export function Transient<C extends string>(code: C, defaultPolicy: RetryPolicy): TransientConstructorVoid<C>;
+export function Transient<D, C extends string = string>(
+  code: C,
+  defaultPolicy: RetryPolicy,
+): TransientFactoryReturn<C, D>;
+export function Transient(
+  code: string,
+  defaultPolicy: RetryPolicy,
+): TransientConstructorVoid<string> | TransientConstructor<string, unknown> {
+  function createTransientError(policyOverride?: Partial<RetryPolicy>): TransientError<string, void>;
+  function createTransientError(data: unknown, policyOverride?: Partial<RetryPolicy>): TransientError<string, unknown>;
+  function createTransientError(dataOrOverride?: unknown, maybeOverride?: Partial<RetryPolicy>) {
+    const override =
+      maybeOverride !== undefined ? maybeOverride : isRetryPolicyLike(dataOrOverride) ? dataOrOverride : undefined;
+
+    const data = maybeOverride !== undefined || override !== undefined ? undefined : dataOrOverride;
+    const mergedPolicy = mergePolicy(defaultPolicy, override);
+    return new TransientError(code, data, mergedPolicy);
+  }
+
+  return Object.assign(createTransientError, {
+    _tag: code,
+    defaultPolicy,
+  });
+}
+
+/**
+ * Type guard to check if value looks like a RetryPolicy (partial).
+ * Used to disambiguate void data + override from actual data.
+ */
+function isRetryPolicyLike(value: unknown): value is Partial<RetryPolicy> {
+  if (typeof value !== 'object' || value === null) return false;
+  // Check for RetryPolicy-specific keys — `in` accepts `object`, no cast needed
+  return (
+    'backoff' in value || 'maxAttempts' in value || 'baseDelayMs' in value || 'maxDelayMs' in value || 'jitter' in value
+  );
+}
+
+// Re-export policy helpers for convenience
+export { exponentialBackoff, fixedDelay, linearBackoff, mergePolicy, type RetryPolicy } from './retry-policy.js';

package/src/lib/errors/__tests__/Blocked-config.test.ts

@@ -0,0 +1,152 @@
+import { describe, expect, it } from 'bun:test';
+import { Blocked, type BlockedConfig } from '../Blocked.js';
+
+describe('Blocked with BlockedConfig', () => {
+  describe('Blocked.service', () => {
+    it('should work with no config', () => {
+      const err = Blocked.service('payment-api');
+      expect(err.reason).toEqual({ type: 'service', name: 'payment-api' });
+      expect(err.blockedConfig).toBeUndefined();
+    });
+
+    it('should work with BlockedConfig (nextRetry closure)', () => {
+      const nextRetry = (attempt: number) => 5000 * 2 ** (attempt - 1);
+      const config: BlockedConfig = { maxAttempts: 5, nextRetry };
+      const err = Blocked.service('payment-api', config);
+      expect(err.reason).toEqual({ type: 'service', name: 'payment-api' });
+      expect(err.blockedConfig).toEqual(config);
+      expect(err.blockedConfig?.nextRetry).toBe(nextRetry);
+    });
+
+    it('should work with BlockedConfig that has only maxAttempts', () => {
+      const config: BlockedConfig = { maxAttempts: 3 };
+      const err = Blocked.service('payment-api', config);
+      expect(err.blockedConfig).toEqual(config);
+    });
+
+    it('should work with BlockedConfig that has only nextRetry', () => {
+      const nextRetry = () => 1000;
+      const config: BlockedConfig = { nextRetry };
+      const err = Blocked.service('payment-api', config);
+      expect(err.blockedConfig).toEqual(config);
+      expect(err.blockedConfig?.nextRetry?.(1)).toBe(1000);
+    });
+  });
+
+  describe('Blocked.ended', () => {
+    it('should work with BlockedConfig', () => {
+      const config: BlockedConfig = { maxAttempts: 10 };
+      const err = Blocked.ended('ax-123', config);
+      expect(err.reason).toEqual({ type: 'ended', target: 'ax-123' });
+      expect(err.blockedConfig).toEqual(config);
+    });
+  });
+
+  describe('Blocked.index', () => {
+    it('should work with BlockedConfig', () => {
+      const nextRetry = (attempt: number) => 1000 * attempt;
+      const config: BlockedConfig = { maxAttempts: 5, nextRetry };
+      const err = Blocked.index('orders-index', config);
+      expect(err.reason).toEqual({ type: 'index', indexName: 'orders-index' });
+      expect(err.blockedConfig).toEqual(config);
+    });
+  });
+
+  describe('.blockedConfig getter', () => {
+    it('should return BlockedConfig when given BlockedConfig', () => {
+      const config: BlockedConfig = { maxAttempts: 3, nextRetry: () => 500 };
+      const err = Blocked.service('api', config);
+      expect(err.blockedConfig).toBe(config);
+    });
+
+    it('should return undefined when no config', () => {
+      const err = Blocked.service('api');
+      expect(err.blockedConfig).toBeUndefined();
+    });
+  });
+
+  describe('serialization', () => {
+    it('should include blockedConfig in toJSON', () => {
+      const config: BlockedConfig = { maxAttempts: 3, nextRetry: () => 1000 };
+      const err = Blocked.service('api', config);
+      const json = err.toJSON();
+      expect(json).toEqual({
+        _tag: 'Blocked',
+        reason: { type: 'service', name: 'api' },
+        blockedConfig: { maxAttempts: 3, nextRetry: '[closure]' },
+      });
+    });
+
+    it('should omit blockedConfig in toJSON when no config', () => {
+      const err = Blocked.service('api');
+      const json = err.toJSON();
+      expect(json).toEqual({
+        _tag: 'Blocked',
+        reason: { type: 'service', name: 'api' },
+      });
+    });
+
+    it('should include blockedConfig in inspect', () => {
+      const config: BlockedConfig = { maxAttempts: 3, nextRetry: () => 1000 };
+      const err = Blocked.service('api', config);
+      const inspectSymbol = Symbol.for('nodejs.util.inspect.custom');
+      const inspectFn = Reflect.get(err, inspectSymbol);
+      if (typeof inspectFn !== 'function') {
+        throw new Error('Expected Blocked inspect hook to be defined');
+      }
+
+      const inspected = inspectFn.call(err);
+      expect(inspected).toEqual({
+        _tag: 'Blocked',
+        reason: { type: 'service', name: 'api' },
+        blockedConfig: config,
+      });
+    });
+  });
+
+  describe('nextRetry closure captures context', () => {
+    it('should use captured Retry-After value on first attempt', () => {
+      const retryAfterMs = 30000;
+      const config: BlockedConfig = {
+        maxAttempts: 5,
+        nextRetry: (attempt) => {
+          if (attempt === 1 && retryAfterMs > 0) return retryAfterMs;
+          return 5000 * 2 ** (attempt - 1);
+        },
+      };
+
+      const err = Blocked.service('payment-api', config);
+      const nextRetry = err.blockedConfig?.nextRetry;
+      if (!nextRetry) {
+        throw new Error('Expected blockedConfig.nextRetry to be defined');
+      }
+
+      expect(nextRetry(1)).toBe(30000);
+      expect(nextRetry(2)).toBe(10000);
+      expect(nextRetry(3)).toBe(20000);
+    });
+  });
+
+  describe('Error properties', () => {
+    it('should be an instance of Error', () => {
+      const err = Blocked.service('api');
+      expect(err).toBeInstanceOf(Error);
+      expect(err).toBeInstanceOf(Blocked);
+    });
+
+    it('should have correct message', () => {
+      expect(Blocked.service('payment-api').message).toBe('Blocked: payment-api');
+      expect(Blocked.ended('ax-123').message).toBe('Blocked: ax-123');
+      expect(Blocked.index('orders').message).toBe('Blocked: orders');
+    });
+
+    it('should have name "Blocked"', () => {
+      expect(Blocked.service('api').name).toBe('Blocked');
+    });
+
+    it('should have _tag "Blocked"', () => {
+      expect(Blocked.service('api')._tag).toBe('Blocked');
+      expect(Blocked._tag).toBe('Blocked');
+    });
+  });
+});

package/src/lib/errors/__tests__/Transient.test.ts

@@ -0,0 +1,129 @@
+import { describe, expect, it } from 'bun:test';
+import { CodeError } from '../CodeError.js';
+import { exponentialBackoff, fixedDelay, linearBackoff, Transient, TransientError } from '../Transient.js';
+
+describe('TransientError', () => {
+  describe('class', () => {
+    it('should extend CodeError', () => {
+      const policy = linearBackoff(3);
+      const error = new TransientError('TEST_CODE', { foo: 'bar' }, policy);
+      expect(error).toBeInstanceOf(CodeError);
+      expect(error).toBeInstanceOf(TransientError);
+      expect(error).toBeInstanceOf(Error);
+    });
+
+    it('should have name TransientError', () => {
+      const error = new TransientError('TEST', {}, linearBackoff(3));
+      expect(error.name).toBe('TransientError');
+    });
+
+    it('should carry policy', () => {
+      const policy = exponentialBackoff(5);
+      const error = new TransientError('NETWORK', { service: 'api' }, policy);
+      expect(error.policy).toBe(policy);
+      expect(error.policy.maxAttempts).toBe(5);
+      expect(error.policy.backoff).toBe('exponential');
+    });
+
+    it('should include policy in toJSON', () => {
+      const policy = fixedDelay(2, 1000);
+      const error = new TransientError('RATE_LIMITED', { ms: 1000 }, policy);
+      const json = error.toJSON();
+      expect(json).toEqual({
+        code: 'RATE_LIMITED',
+        data: { ms: 1000 },
+        policy: {
+          backoff: 'fixed',
+          maxAttempts: 2,
+          baseDelayMs: 1000,
+          jitter: false,
+        },
+      });
+    });
+  });
+
+  describe('Transient() factory', () => {
+    it('should create TransientError with default policy', () => {
+      const SERVICE_UNAVAILABLE = Transient<{ status: number }>('SERVICE_UNAVAILABLE', exponentialBackoff(5));
+      const error = SERVICE_UNAVAILABLE({ status: 503 });
+
+      expect(error).toBeInstanceOf(TransientError);
+      expect(error.code).toBe('SERVICE_UNAVAILABLE');
+      expect(error.data).toEqual({ status: 503 });
+      expect(error.policy.maxAttempts).toBe(5);
+      expect(error.policy.backoff).toBe('exponential');
+    });
+
+    it('should have static _tag property', () => {
+      const NETWORK_ERROR = Transient<{ service: string }>('NETWORK_ERROR', linearBackoff(3));
+      expect(NETWORK_ERROR._tag).toBe('NETWORK_ERROR');
+    });
+
+    it('should have static defaultPolicy property', () => {
+      const policy = exponentialBackoff(5);
+      const TIMEOUT = Transient('TIMEOUT', policy);
+      expect(TIMEOUT.defaultPolicy).toBe(policy);
+    });
+
+    it('should allow policy override per-call', () => {
+      const SERVICE_UNAVAILABLE = Transient<{ status: number }>('SERVICE_UNAVAILABLE', exponentialBackoff(5));
+
+      // Use default
+      const error1 = SERVICE_UNAVAILABLE({ status: 503 });
+      expect(error1.policy.maxAttempts).toBe(5);
+      expect(error1.policy.backoff).toBe('exponential');
+
+      // Override maxAttempts
+      const error2 = SERVICE_UNAVAILABLE({ status: 503 }, { maxAttempts: 2 });
+      expect(error2.policy.maxAttempts).toBe(2);
+      expect(error2.policy.backoff).toBe('exponential'); // Unchanged
+
+      // Override entire policy
+      const error3 = SERVICE_UNAVAILABLE({ status: 503 }, fixedDelay(1, 60000));
+      expect(error3.policy.maxAttempts).toBe(1);
+      expect(error3.policy.backoff).toBe('fixed');
+      expect(error3.policy.baseDelayMs).toBe(60000);
+    });
+
+    it('should work with void data', () => {
+      const TIMEOUT = Transient('TIMEOUT', linearBackoff(3));
+
+      // No args - use default policy
+      const error1 = TIMEOUT();
+      expect(error1.code).toBe('TIMEOUT');
+      expect(error1.data).toBeUndefined();
+      expect(error1.policy.maxAttempts).toBe(3);
+
+      // Policy override only (void data)
+      const error2 = TIMEOUT({ maxAttempts: 1 });
+      expect(error2.data).toBeUndefined();
+      expect(error2.policy.maxAttempts).toBe(1);
+    });
+
+    it('should enable instanceof checks for retry classification', () => {
+      const SERVICE_DOWN = Transient<{ service: string }>('SERVICE_DOWN', exponentialBackoff(5));
+      const error = SERVICE_DOWN({ service: 'payment' });
+
+      // This is the key use case - Op class uses this check
+      expect(error instanceof TransientError).toBe(true);
+      expect(error instanceof CodeError).toBe(true);
+    });
+
+    it('should distinguish from regular CodeError', async () => {
+      const { Code } = await import('../CodeError.js');
+
+      const TRANSIENT_ERR = Transient<{ reason: string }>('SOME_ERROR', linearBackoff(3));
+      const REGULAR_ERR = Code<{ reason: string }>('SOME_ERROR');
+
+      const transientError = TRANSIENT_ERR({ reason: 'network' });
+      const regularError = REGULAR_ERR({ reason: 'validation' });
+
+      // Same code, different instanceof
+      expect(transientError.code).toBe('SOME_ERROR');
+      expect(regularError.code).toBe('SOME_ERROR');
+
+      expect(transientError instanceof TransientError).toBe(true);
+      expect(regularError instanceof TransientError).toBe(false);
+    });
+  });
+});

package/src/lib/errors/__tests__/retry-policy.test.ts

@@ -0,0 +1,85 @@
+import { describe, expect, it } from 'bun:test';
+import { exponentialBackoff, fixedDelay, linearBackoff, mergePolicy } from '../retry-policy.js';
+
+describe('RetryPolicy helpers', () => {
+  describe('linearBackoff', () => {
+    it('should create linear policy with defaults', () => {
+      const policy = linearBackoff(3);
+      expect(policy).toEqual({
+        backoff: 'linear',
+        maxAttempts: 3,
+        baseDelayMs: 100,
+        jitter: true,
+      });
+    });
+
+    it('should accept custom baseDelayMs', () => {
+      const policy = linearBackoff(5, 200);
+      expect(policy.maxAttempts).toBe(5);
+      expect(policy.baseDelayMs).toBe(200);
+    });
+  });
+
+  describe('exponentialBackoff', () => {
+    it('should create exponential policy with defaults', () => {
+      const policy = exponentialBackoff(5);
+      expect(policy).toEqual({
+        backoff: 'exponential',
+        maxAttempts: 5,
+        baseDelayMs: 100,
+        jitter: true,
+      });
+    });
+
+    it('should accept custom baseDelayMs', () => {
+      const policy = exponentialBackoff(3, 50);
+      expect(policy.maxAttempts).toBe(3);
+      expect(policy.baseDelayMs).toBe(50);
+    });
+  });
+
+  describe('fixedDelay', () => {
+    it('should create fixed policy with defaults', () => {
+      const policy = fixedDelay(3);
+      expect(policy).toEqual({
+        backoff: 'fixed',
+        maxAttempts: 3,
+        baseDelayMs: 1000,
+        jitter: false,
+      });
+    });
+
+    it('should accept custom delayMs', () => {
+      const policy = fixedDelay(1, 60000);
+      expect(policy.maxAttempts).toBe(1);
+      expect(policy.baseDelayMs).toBe(60000);
+    });
+  });
+
+  describe('mergePolicy', () => {
+    it('should return base when no override', () => {
+      const base = linearBackoff(3);
+      expect(mergePolicy(base)).toBe(base);
+      expect(mergePolicy(base, undefined)).toBe(base);
+    });
+
+    it('should merge override fields', () => {
+      const base = exponentialBackoff(5);
+      const merged = mergePolicy(base, { maxAttempts: 3 });
+      expect(merged.maxAttempts).toBe(3);
+      expect(merged.backoff).toBe('exponential');
+      expect(merged.baseDelayMs).toBe(100);
+    });
+
+    it('should override multiple fields', () => {
+      const base = linearBackoff(5, 100);
+      const merged = mergePolicy(base, { maxAttempts: 2, baseDelayMs: 500, jitter: false });
+      expect(merged).toEqual({
+        backoff: 'linear',
+        maxAttempts: 2,
+        baseDelayMs: 500,
+        jitter: false,
+      });
+    });
+  });
+});

package/src/lib/errors/index.ts

@@ -0,0 +1,24 @@
+/**
+ * Error types and utilities for LMAO.
+ *
+ * @example
+ * ```typescript
+ * import { Code, CodeError, Transient, TransientError, Blocked, exponentialBackoff } from '@smoothbricks/lmao/errors';
+ * ```
+ */
+
+export * from './Blocked.js';
+// Existing exports
+export * from './CodeError.js';
+export * from './RetriesExhausted.js';
+
+// Phase 19 exports - TransientError uses RetryPolicy from retry-policy.ts
+// Export with different name to avoid conflict with other retry configs
+export {
+  exponentialBackoff,
+  fixedDelay,
+  linearBackoff,
+  mergePolicy,
+  type RetryPolicy as TransientRetryPolicy,
+} from './retry-policy.js';
+export { Transient, type TransientConstructor, type TransientConstructorVoid, TransientError } from './Transient.js';