@teever/ez-hook-effect 0.5.1 → 0.5.19

package/dist/index.js

@@ -1,615 +1,8 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-
-// src/errors/WebhookError.ts
-import { Data } from "effect";
-
-class WebhookError extends Data.TaggedError("WebhookError") {
-}
-var extractConstraint = (message) => {
-  if (message.includes("at most") || message.includes("maximum"))
-    return "MaxLength";
-  if (message.includes("at least") || message.includes("minimum"))
-    return "MinLength";
-  if (message.includes("required") || message.includes("missing"))
-    return "Required";
-  if (message.includes("expected") && message.includes("to be"))
-    return "Type";
-  if (message.includes("URL") || message.includes("url"))
-    return "URL";
-  if (message.includes("integer") || message.includes("number"))
-    return "Number";
-  return;
-};
-var truncateValue = (value, maxLength = 100) => {
-  if (typeof value === "string" && value.length > maxLength) {
-    return `${value.slice(0, maxLength)}... (${value.length} chars)`;
-  }
-  if (Array.isArray(value) && value.length > 5) {
-    return `[Array with ${value.length} items]`;
-  }
-  if (typeof value === "object" && value !== null) {
-    const keys = Object.keys(value);
-    if (keys.length > 5) {
-      return `{Object with ${keys.length} keys}`;
-    }
-  }
-  return value;
-};
-var pathToString = (path) => {
-  if (path.length === 0)
-    return "$";
-  return path.reduce((acc, segment) => {
-    if (typeof segment === "number") {
-      return `${acc}[${segment}]`;
-    }
-    return `${acc}.${String(segment)}`;
-  }, "$");
-};
-var toArray = (value) => Array.isArray(value) ? value : [value];
-var getIssueProp = (issue, key) => issue[key];
-var extractIssuesFromParseIssue = (issue, currentPath = []) => {
-  const issues = [];
-  switch (issue._tag) {
-    case "InvalidType": {
-      const ast = getIssueProp(issue, "ast");
-      const message = getIssueProp(issue, "message") ?? `Expected ${ast?._tag}`;
-      issues.push({
-        path: pathToString(currentPath),
-        message,
-        constraint: extractConstraint(message) ?? "Type",
-        actual: truncateValue(getIssueProp(issue, "actual"))
-      });
-      break;
-    }
-    case "Forbidden": {
-      issues.push({
-        path: pathToString(currentPath),
-        message: getIssueProp(issue, "message") ?? "Value is forbidden",
-        constraint: "Forbidden"
-      });
-      break;
-    }
-    case "MissingKey": {
-      issues.push({
-        path: pathToString(currentPath),
-        message: "Required field is missing",
-        constraint: "Required"
-      });
-      break;
-    }
-    case "UnexpectedKey": {
-      issues.push({
-        path: pathToString(currentPath),
-        message: getIssueProp(issue, "message") ?? "Unexpected field",
-        constraint: "Unexpected",
-        actual: truncateValue(getIssueProp(issue, "actual"))
-      });
-      break;
-    }
-    case "Pointer": {
-      const pathSegments = getIssueProp(issue, "path") ?? [];
-      const newPath = [...currentPath, ...pathSegments];
-      const nested = getIssueProp(issue, "issue");
-      if (nested)
-        issues.push(...extractIssuesFromParseIssue(nested, newPath));
-      break;
-    }
-    case "Composite": {
-      const rawIssues = getIssueProp(issue, "issues");
-      const subIssues = rawIssues ? toArray(rawIssues) : [];
-      for (const subIssue of subIssues) {
-        issues.push(...extractIssuesFromParseIssue(subIssue, currentPath));
-      }
-      break;
-    }
-    case "Filter":
-    case "Encoding": {
-      const nested = getIssueProp(issue, "issue");
-      if (nested)
-        issues.push(...extractIssuesFromParseIssue(nested, currentPath));
-      break;
-    }
-    case "InvalidValue":
-    case "OneOf":
-    case "AnyOf": {
-      issues.push({
-        path: pathToString(currentPath),
-        message: getIssueProp(issue, "message") ?? "Invalid value",
-        constraint: "Value",
-        actual: truncateValue(getIssueProp(issue, "actual"))
-      });
-      break;
-    }
-    default: {
-      const message = getIssueProp(issue, "message") ?? "Invalid value";
-      const constraint = extractConstraint(message);
-      issues.push({
-        path: pathToString(currentPath),
-        message,
-        ...constraint !== undefined && { constraint },
-        ...getIssueProp(issue, "actual") !== undefined && {
-          actual: truncateValue(getIssueProp(issue, "actual"))
-        }
-      });
-      break;
-    }
-  }
-  return issues;
-};
-var parseErrorToIssues = (error) => {
-  return extractIssuesFromParseIssue(error.issue);
-};
-var makeIssue = (field, message, options) => {
-  const constraint = options?.constraint ?? extractConstraint(message);
-  return {
-    path: field.startsWith("$") ? field : `$.${field}`,
-    message,
-    ...constraint !== undefined && { constraint },
-    ...options?.expected !== undefined && { expected: options.expected },
-    ...options?.actual !== undefined && {
-      actual: truncateValue(options.actual)
-    }
-  };
-};
-
-class ValidationError extends Data.TaggedError("ValidationError") {
-  format(options) {
-    const maxIssues = options?.maxIssues ?? 10;
-    const displayIssues = this.issues.slice(0, maxIssues);
-    const lines = displayIssues.map((issue) => {
-      let line = `  - ${issue.path}: ${issue.message}`;
-      if (issue.constraint) {
-        line += ` [${issue.constraint}]`;
-      }
-      return line;
-    });
-    if (this.issues.length > maxIssues) {
-      lines.push(`  ... and ${this.issues.length - maxIssues} more issues`);
-    }
-    return `${this.message}
-${lines.join(`
-`)}`;
-  }
-  static fromParseError(parseError, context) {
-    const issues = parseErrorToIssues(parseError);
-    const firstIssue = issues[0];
-    const message = issues.length === 1 && firstIssue ? firstIssue.message : `Validation failed (${issues.length} issues)`;
-    return new ValidationError({
-      message,
-      issues,
-      ...context?.field !== undefined && { field: context.field },
-      ...context?.value !== undefined && { value: context.value }
-    });
-  }
-  static fromIssue(field, message, options) {
-    const issue = makeIssue(field, message, options);
-    return new ValidationError({
-      message,
-      issues: [issue],
-      field,
-      value: options?.actual
-    });
-  }
-}
-
-class NetworkError extends Data.TaggedError("NetworkError") {
-}
-
-class RateLimitError extends Data.TaggedError("RateLimitError") {
-}
-
-class ConfigError extends Data.TaggedError("ConfigError") {
-}
-
-class FileError extends Data.TaggedError("FileError") {
-}
-
-class HttpError extends Data.TaggedError("HttpError") {
-}
-var formatWebhookError = (error, options) => {
-  switch (error._tag) {
-    case "ValidationError":
-      return error.format(options);
-    case "RateLimitError":
-      return `${error.message} (retryAfter=${error.retryAfter}ms)`;
-    case "HttpError": {
-      const status = error.response?.status;
-      return status ? `${error.message} (status=${status})` : error.message;
-    }
-    default:
-      return error.message;
-  }
-};
-var webhookErrorToLogObject = (error) => {
-  switch (error._tag) {
-    case "ValidationError":
-      return {
-        tag: error._tag,
-        message: error.message,
-        issues: error.issues,
-        field: error.field,
-        value: error.value
-      };
-    case "RateLimitError":
-      return {
-        tag: error._tag,
-        message: error.message,
-        retryAfter: error.retryAfter,
-        limit: error.limit,
-        remaining: error.remaining,
-        reset: error.reset
-      };
-    case "HttpError":
-      return {
-        tag: error._tag,
-        message: error.message,
-        request: error.request,
-        response: error.response
-      };
-    case "NetworkError":
-      return {
-        tag: error._tag,
-        message: error.message,
-        statusCode: error.statusCode,
-        response: error.response
-      };
-    case "ConfigError":
-      return {
-        tag: error._tag,
-        message: error.message,
-        parameter: error.parameter
-      };
-    case "FileError":
-      return {
-        tag: error._tag,
-        message: error.message,
-        filename: error.filename,
-        size: error.size,
-        maxSize: error.maxSize
-      };
-    default:
-      return {
-        tag: error._tag,
-        message: error.message,
-        cause: error.cause
-      };
-  }
-};
-// src/layers/Config.ts
-import { Effect, Layer, ServiceMap } from "effect";
-
-// src/schemas/Discord.ts
-import { Schema } from "effect";
-var DISCORD_WEBHOOK_REGEX = /^https:\/\/(?:(?:canary|ptb)\.)?discord(?:app)?\.com\/api(?:\/v\d+)?\/webhooks\/(?<id>\d+)\/(?<token>[\w-]+)\/?$/;
-var DiscordWebhookUrl = Schema.String.check(Schema.isPattern(DISCORD_WEBHOOK_REGEX, {
-  message: "Invalid Discord webhook URL"
-}));
-
-// src/layers/Config.ts
-class Config extends ServiceMap.Service()("Config") {
-}
-var validateWebhookUrl = (url) => {
-  if (!url || url.trim() === "") {
-    return Effect.fail(new ConfigError({
-      message: `Webhook URL is empty. Please provide a valid Discord webhook URL.
-` + `Format: https://discord.com/api/webhooks/{webhook_id}/{webhook_token}
-` + "You can create a webhook in Discord: Server Settings > Integrations > Webhooks",
-      parameter: "webhookUrl"
-    }));
-  }
-  if (!url.startsWith("https://")) {
-    return Effect.fail(new ConfigError({
-      message: `Webhook URL must use HTTPS protocol.
-` + `Received: ${url.substring(0, 50)}${url.length > 50 ? "..." : ""}
-` + "Expected format: https://discord.com/api/webhooks/{webhook_id}/{webhook_token}",
-      parameter: "webhookUrl"
-    }));
-  }
-  if (!DISCORD_WEBHOOK_REGEX.test(url)) {
-    const isDiscordDomain = url.includes("discord.com") || url.includes("discordapp.com");
-    const hasWebhooksPath = url.includes("/webhooks/");
-    let hint = "";
-    if (!isDiscordDomain) {
-      hint = "URL must be from discord.com or discordapp.com domain.";
-    } else if (!hasWebhooksPath) {
-      hint = "URL must include /api/webhooks/ path.";
-    } else {
-      hint = "URL must include both webhook ID (numeric) and token after /webhooks/.";
-    }
-    return Effect.fail(new ConfigError({
-      message: `Invalid Discord webhook URL format.
-` + `${hint}
-` + `Received: ${url.substring(0, 80)}${url.length > 80 ? "..." : ""}
-` + `Expected format: https://discord.com/api/webhooks/{webhook_id}/{webhook_token}`,
-      parameter: "webhookUrl"
-    }));
-  }
-  return Effect.succeed(url);
-};
-var validateRetryOptions = (options) => {
-  const errors = [];
-  if (options?.maxRetries !== undefined) {
-    if (!Number.isInteger(options.maxRetries) || options.maxRetries < 0) {
-      errors.push(`maxRetries must be a non-negative integer (received: ${options.maxRetries})`);
-    }
-    if (options.maxRetries > 10) {
-      errors.push(`maxRetries should not exceed 10 to avoid excessive retries (received: ${options.maxRetries})`);
-    }
-  }
-  if (options?.baseDelayMs !== undefined) {
-    if (!Number.isInteger(options.baseDelayMs) || options.baseDelayMs < 0) {
-      errors.push(`baseDelayMs must be a non-negative integer (received: ${options.baseDelayMs})`);
-    }
-    if (options.baseDelayMs > 60000) {
-      errors.push(`baseDelayMs should not exceed 60000ms (received: ${options.baseDelayMs})`);
-    }
-  }
-  if (options?.maxDelayMs !== undefined) {
-    if (!Number.isInteger(options.maxDelayMs) || options.maxDelayMs < 0) {
-      errors.push(`maxDelayMs must be a non-negative integer (received: ${options.maxDelayMs})`);
-    }
-    if (options.baseDelayMs !== undefined && options.maxDelayMs < options.baseDelayMs) {
-      errors.push(`maxDelayMs (${options.maxDelayMs}) must be >= baseDelayMs (${options.baseDelayMs})`);
-    }
-  }
-  if (errors.length > 0) {
-    return Effect.fail(new ConfigError({
-      message: `Invalid retry configuration:
-${errors.map((e) => `  - ${e}`).join(`
-`)}`,
-      parameter: "retryConfig"
-    }));
-  }
-  return Effect.succeed(options);
-};
-var makeConfig = (webhookUrl, options) => Effect.gen(function* () {
-  const validatedUrl = yield* validateWebhookUrl(webhookUrl);
-  yield* validateRetryOptions(options);
-  return {
-    webhook: {
-      webhookUrl: validatedUrl,
-      maxRetries: options?.maxRetries ?? 3,
-      baseDelayMs: options?.baseDelayMs ?? 1000,
-      maxDelayMs: options?.maxDelayMs ?? 60000,
-      enableJitter: options?.enableJitter ?? true
-    }
-  };
-});
-var makeConfigLayer = (webhookUrl, options) => Layer.effect(Config, makeConfig(webhookUrl, options));
-var ConfigFromEnv = Layer.effect(Config, Effect.gen(function* () {
-  const rawWebhookUrl = yield* Effect.sync(() => process.env.DISCORD_WEBHOOK_URL ?? "");
-  if (!rawWebhookUrl) {
-    return yield* Effect.fail(new ConfigError({
-      message: `DISCORD_WEBHOOK_URL environment variable not set.
-` + `Please set DISCORD_WEBHOOK_URL in your environment or .env file.
-` + "See .env.example for all available configuration options.",
-      parameter: "DISCORD_WEBHOOK_URL"
-    }));
-  }
-  const webhookUrl = yield* validateWebhookUrl(rawWebhookUrl);
-  const maxRetries = yield* Effect.sync(() => {
-    const v = process.env.WEBHOOK_MAX_RETRIES;
-    return v ? Number.parseInt(v, 10) : 3;
-  });
-  const baseDelayMs = yield* Effect.sync(() => {
-    const v = process.env.WEBHOOK_BASE_DELAY_MS;
-    return v ? Number.parseInt(v, 10) : 1000;
-  });
-  const maxDelayMs = yield* Effect.sync(() => {
-    const v = process.env.WEBHOOK_MAX_DELAY_MS;
-    return v ? Number.parseInt(v, 10) : 60000;
-  });
-  const enableJitter = yield* Effect.sync(() => {
-    const v = process.env.WEBHOOK_ENABLE_JITTER;
-    return v ? v === "true" : true;
-  });
-  yield* validateRetryOptions({ maxRetries, baseDelayMs, maxDelayMs });
-  return {
-    webhook: {
-      webhookUrl,
-      maxRetries,
-      baseDelayMs,
-      maxDelayMs,
-      enableJitter
-    }
-  };
-}));
-var parseWebhookUrl = (url) => Effect.gen(function* () {
-  const match = url.match(DISCORD_WEBHOOK_REGEX);
-  if (!match?.groups?.id || !match.groups.token) {
-    return yield* Effect.fail(new ConfigError({
-      message: "Invalid webhook URL format",
-      parameter: "webhookUrl"
-    }));
-  }
-  const { id, token } = match.groups;
-  return { id, token };
-});
-// src/layers/HttpClient.ts
-import { Duration, Effect as Effect2, Layer as Layer2, Schedule, ServiceMap as ServiceMap2 } from "effect";
-class HttpClient extends ServiceMap2.Service()("HttpClient") {
-}
-var parseRateLimitHeaders = (headers) => {
-  const retryAfterHeader = headers["retry-after"];
-  const rateLimitRemaining = headers["x-ratelimit-remaining"];
-  if (!retryAfterHeader && rateLimitRemaining !== "0") {
-    return null;
-  }
-  let retryAfter = 0;
-  if (retryAfterHeader) {
-    const parsed = Number.parseFloat(retryAfterHeader);
-    if (!Number.isNaN(parsed)) {
-      retryAfter = Math.ceil(parsed * 1000);
-    }
-  }
-  const limit = headers["x-ratelimit-limit"];
-  const remaining = headers["x-ratelimit-remaining"];
-  const resetHeader = headers["x-ratelimit-reset"];
-  const resetAfterHeader = headers["x-ratelimit-reset-after"];
-  const globalHeader = headers["x-ratelimit-global"];
-  let reset;
-  if (resetHeader) {
-    const resetTimestamp = Number.parseFloat(resetHeader);
-    if (!Number.isNaN(resetTimestamp)) {
-      reset = new Date(resetTimestamp * 1000);
-    }
-  } else if (resetAfterHeader) {
-    const resetAfter = Number.parseFloat(resetAfterHeader);
-    if (!Number.isNaN(resetAfter)) {
-      reset = new Date(Date.now() + resetAfter * 1000);
-    }
-  }
-  if (retryAfter === 0 && reset) {
-    retryAfter = Math.max(0, reset.getTime() - Date.now());
-  }
-  if (retryAfter === 0) {
-    retryAfter = 1000;
-  }
-  return {
-    retryAfter,
-    ...limit && { limit: Number.parseInt(limit, 10) },
-    ...remaining && { remaining: Number.parseInt(remaining, 10) },
-    ...reset && { reset },
-    global: globalHeader === "true"
-  };
-};
-var defaultRetryConfig = {
-  maxRetries: 3,
-  baseDelay: Duration.seconds(1),
-  maxDelay: Duration.seconds(60),
-  jitter: true
-};
-var createRetrySchedule = (config) => {
-  const capDelay = (delay) => Duration.isLessThanOrEqualTo(delay, config.maxDelay) ? delay : config.maxDelay;
-  let policy = Schedule.exponential(config.baseDelay, 2);
-  if (config.jitter) {
-    policy = policy.pipe(Schedule.modifyDelay((_, delay) => Effect2.sync(() => {
-      const millis = Duration.toMillis(delay);
-      return Duration.millis(millis + Math.random() * millis);
-    })));
-  }
-  policy = policy.pipe(Schedule.modifyDelay((_, delay) => Effect2.succeed(capDelay(delay))));
-  const capped = Schedule.both(policy, Schedule.recurs(config.maxRetries));
-  return capped.pipe(Schedule.map(([delay]) => Effect2.succeed(delay)));
-};
-var FetchHttpClient = (retryConfig = defaultRetryConfig) => ({
-  retryConfig,
-  request: (request) => Effect2.gen(function* () {
-    const controller = new AbortController;
-    const timeout = request.timeout ? setTimeout(() => controller.abort(), Duration.toMillis(request.timeout)) : undefined;
-    const requestHeaders = new Headers({
-      "Content-Type": "application/json"
-    });
-    for (const [key, value] of Object.entries(request.headers ?? {})) {
-      requestHeaders.set(key, value);
-    }
-    const response = yield* Effect2.tryPromise({
-      try: () => fetch(request.url, {
-        method: request.method,
-        headers: requestHeaders,
-        body: request.body ? JSON.stringify(request.body) : undefined,
-        signal: controller.signal
-      }),
-      catch: (error) => new NetworkError({
-        message: `Network request failed: ${error instanceof Error ? error.message : String(error)}`,
-        statusCode: 0
-      })
-    });
-    if (timeout)
-      clearTimeout(timeout);
-    const rawTextOrFn = yield* Effect2.tryPromise({
-      try: () => response.text(),
-      catch: () => new NetworkError({ message: "Failed to read response body" })
-    });
-    const text = typeof rawTextOrFn === "function" ? yield* Effect2.tryPromise({
-      try: () => rawTextOrFn(),
-      catch: () => new NetworkError({ message: "Failed to read response body" })
-    }) : String(rawTextOrFn ?? "");
-    const headers = {};
-    response.headers.forEach((value, key) => {
-      headers[key.toLowerCase()] = value;
-    });
-    let body = text;
-    if (headers["content-type"]?.includes("application/json") && text) {
-      try {
-        body = JSON.parse(text);
-      } catch {}
-    }
-    const httpResponse = {
-      status: response.status,
-      statusText: response.statusText,
-      headers,
-      body,
-      text
-    };
-    if (!response.ok) {
-      if (response.status === 429) {
-        const rateLimitInfo = parseRateLimitHeaders(headers);
-        return yield* Effect2.fail(new RateLimitError({
-          message: `Rate limited: retry after ${rateLimitInfo?.retryAfter ?? 1000}ms`,
-          retryAfter: rateLimitInfo?.retryAfter ?? 1000,
-          ...rateLimitInfo?.limit !== undefined && {
-            limit: rateLimitInfo.limit
-          },
-          ...rateLimitInfo?.remaining !== undefined && {
-            remaining: rateLimitInfo.remaining
-          },
-          ...rateLimitInfo?.reset !== undefined && {
-            reset: rateLimitInfo.reset
-          }
-        }));
-      }
-      return yield* Effect2.fail(new HttpError({
-        message: `HTTP ${response.status}: ${response.statusText}`,
-        request: {
-          method: request.method,
-          url: request.url
-        },
-        response: {
-          status: response.status,
-          statusText: response.statusText,
-          headers,
-          body
-        }
-      }));
-    }
-    return httpResponse;
-  })
-});
-var HttpClientLive = Layer2.succeed(HttpClient, FetchHttpClient());
-var makeHttpClientLayer = (retryConfig) => Layer2.succeed(HttpClient, FetchHttpClient({ ...defaultRetryConfig, ...retryConfig }));
-var makeTestHttpClient = (resolver, retryConfig = defaultRetryConfig) => Layer2.succeed(HttpClient, {
-  request: resolver,
-  retryConfig
-});
-// src/layers/Default.ts
-import { Layer as Layer4 } from "effect";
-
-// src/services/WebhookService.ts
-import {
-  Duration as Duration2,
-  Effect as Effect3,
-  Layer as Layer3,
-  pipe,
-  Schedule as Schedule2,
-  Schema as Schema6,
-  ServiceMap as ServiceMap3
-} from "effect";
-
 // src/schemas/Common.ts
-import { Schema as Schema2 } from "effect";
-var maxLength = (max) => Schema2.String.check(Schema2.isMaxLength(max));
-var positiveInt = Schema2.Number.check(Schema2.isInt(), Schema2.isGreaterThan(0));
-var UrlString = Schema2.String.pipe(Schema2.check(Schema2.makeFilter((value) => {
+import { Schema } from "effect";
+var maxLength = (max) => Schema.String.check(Schema.isMaxLength(max));
+var positiveInt = Schema.Number.check(Schema.isInt(), Schema.isGreaterThan(0));
+var UrlString = Schema.String.pipe(Schema.check(Schema.makeFilter((value) => {
   try {
     new URL(value);
     return true;
@@ -617,12 +10,19 @@ var UrlString = Schema2.String.pipe(Schema2.check(Schema2.makeFilter((value) =>
     return "Invalid URL format";
   }
 })));
-var ISO8601Timestamp = Schema2.String.pipe(Schema2.check(Schema2.makeFilter((value) => {
+var ISO8601Timestamp = Schema.String.pipe(Schema.check(Schema.makeFilter((value) => {
   const iso8601Regex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z?$/;
   return iso8601Regex.test(value) ? true : "Invalid ISO8601 timestamp format";
 })));
-var ColorCode = Schema2.Number.check(Schema2.isInt(), Schema2.isGreaterThanOrEqualTo(0), Schema2.isLessThanOrEqualTo(16777215));
-var Uint8ArraySchema = Schema2.instanceOf(Uint8Array);
+var ColorCode = Schema.Number.check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(0), Schema.isLessThanOrEqualTo(16777215));
+var Uint8ArraySchema = Schema.instanceOf(Uint8Array);
+
+// src/schemas/Discord.ts
+import { Schema as Schema2 } from "effect";
+var DISCORD_WEBHOOK_REGEX = /^https:\/\/(?:(?:canary|ptb)\.)?discord(?:app)?\.com\/api(?:\/v\d+)?\/webhooks\/(?<id>\d+)\/(?<token>[\w-]+)\/?$/;
+var DiscordWebhookUrl = Schema2.String.check(Schema2.isPattern(DISCORD_WEBHOOK_REGEX, {
+  message: "Invalid Discord webhook URL"
+}));
 
 // src/schemas/Embed.ts
 import { Schema as Schema4 } from "effect";
@@ -768,354 +168,6 @@ class WebhookResponse extends Schema5.Class("WebhookResponse")({
   url: Schema5.optionalKey(UrlString)
 }) {
 }
-
-// src/utils/normalize.ts
-var stripUndefined = (input) => {
-  if (Array.isArray(input)) {
-    return input.map(stripUndefined);
-  }
-  if (input && typeof input === "object") {
-    const proto = Object.getPrototypeOf(input);
-    if (proto !== Object.prototype && proto !== null) {
-      return input;
-    }
-    const entries = Object.entries(input).filter(([, value]) => value !== undefined).map(([key, value]) => [key, stripUndefined(value)]);
-    return Object.fromEntries(entries);
-  }
-  return input;
-};
-
-// src/services/WebhookService.ts
-class WebhookService extends ServiceMap3.Service()("WebhookService") {
-}
-var makeWebhookService = Effect3.gen(function* () {
-  const config = yield* Config;
-  const httpClient = yield* HttpClient;
-  const webhookUrl = config.webhook.webhookUrl;
-  const retrySchedule = createRetrySchedule({
-    maxRetries: config.webhook.maxRetries ?? httpClient.retryConfig.maxRetries,
-    baseDelay: Duration2.millis(config.webhook.baseDelayMs ?? Duration2.toMillis(httpClient.retryConfig.baseDelay)),
-    maxDelay: Duration2.millis(config.webhook.maxDelayMs ?? Duration2.toMillis(httpClient.retryConfig.maxDelay)),
-    jitter: config.webhook.enableJitter ?? httpClient.retryConfig.jitter
-  });
-  const sendWebhookRaw = (webhook) => pipe(Schema6.decodeUnknownEffect(Webhook)(stripUndefined(webhook)), Effect3.mapError((e) => ValidationError.fromParseError(e, { field: "webhook", value: webhook })), Effect3.flatMap((validatedWebhook) => httpClient.request({
-    method: "POST",
-    url: webhookUrl,
-    body: validatedWebhook
-  }).pipe(Effect3.retry(Schedule2.while(retrySchedule, (meta) => Effect3.succeed(meta.input instanceof NetworkError || meta.input instanceof RateLimitError || meta.input instanceof HttpError && (meta.input.response?.status ?? 0) >= 500))))), Effect3.map((response) => ({
-    status: response.status,
-    ok: response.status >= 200 && response.status < 300,
-    headers: response.headers,
-    body: response.body,
-    text: response.text
-  })));
-  const sendWebhook = (webhook) => pipe(sendWebhookRaw(webhook), Effect3.flatMap((response) => response.status === 204 && response.text === "" ? Effect3.void : Effect3.fail(new WebhookError({
-    message: `Unexpected webhook response: ${response.status}`,
-    cause: response
-  }))));
-  const modifyWebhook = (params) => pipe(Schema6.decodeUnknownEffect(WebhookParameter)(stripUndefined(params)), Effect3.mapError((e) => ValidationError.fromParseError(e, { field: "params", value: params })), Effect3.flatMap((validatedParams) => httpClient.request({
-    method: "PATCH",
-    url: webhookUrl,
-    body: validatedParams
-  })), Effect3.flatMap((response) => Schema6.decodeUnknownEffect(WebhookResponse)(response.body).pipe(Effect3.mapError(() => new WebhookError({
-    message: "Invalid webhook response",
-    cause: response.body
-  })))));
-  const getWebhook = () => pipe(httpClient.request({
-    method: "GET",
-    url: webhookUrl
-  }), Effect3.flatMap((response) => Schema6.decodeUnknownEffect(WebhookResponse)(response.body).pipe(Effect3.mapError(() => new WebhookError({
-    message: "Invalid webhook response",
-    cause: response.body
-  })))));
-  const validateWebhook = () => pipe(httpClient.request({
-    method: "GET",
-    url: webhookUrl
-  }), Effect3.as(true), Effect3.catch(() => Effect3.succeed(false)));
-  const deleteWebhook = () => pipe(httpClient.request({
-    method: "DELETE",
-    url: webhookUrl
-  }), Effect3.map((response) => response.status === 204));
-  return {
-    sendWebhook,
-    sendWebhookRaw,
-    modifyWebhook,
-    getWebhook,
-    deleteWebhook,
-    validateWebhook
-  };
-});
-var WebhookServiceLive = Layer3.effect(WebhookService, makeWebhookService);
-var sendWebhook = (webhook) => WebhookService.use((service) => service.sendWebhook(webhook));
-var sendWebhookRaw = (webhook) => WebhookService.use((service) => service.sendWebhookRaw(webhook));
-var modifyWebhook = (params) => WebhookService.use((service) => service.modifyWebhook(params));
-var getWebhook = () => WebhookService.use((service) => service.getWebhook());
-var deleteWebhook = () => WebhookService.use((service) => service.deleteWebhook());
-var validateWebhook = () => WebhookService.use((service) => service.validateWebhook());
-
-// src/layers/Default.ts
-var makeDefaultLayer = (url, options) => WebhookServiceLive.pipe(Layer4.provide(makeConfigLayer(url, options)), Layer4.provide(HttpClientLive));
-// src/pipes/Embed.ts
-var exports_Embed = {};
-__export(exports_Embed, {
-  setVideo: () => setVideo,
-  setURL: () => setURL,
-  setTitle: () => setTitle,
-  setTimestamp: () => setTimestamp,
-  setThumbnail: () => setThumbnail,
-  setProvider: () => setProvider,
-  setImage: () => setImage,
-  setFooter: () => setFooter,
-  setFields: () => setFields,
-  setDescription: () => setDescription,
-  setColor: () => setColor,
-  setAuthor: () => setAuthor,
-  make: () => make,
-  buildDirect: () => buildDirect,
-  build: () => build,
-  addFieldImpl: () => addFieldImpl,
-  addFieldDirect: () => addFieldDirect,
-  addField: () => addField
-});
-import { Effect as Effect4, pipe as pipe2, Schema as Schema7 } from "effect";
-var createDraft = () => ({});
-var setTitleImpl = (title) => (d) => pipe2(Schema7.decodeUnknownEffect(maxLength(256))(title), Effect4.mapError(() => ValidationError.fromIssue("title", "Title must be 256 characters or less", {
-  constraint: "MaxLength",
-  expected: "256 characters or less",
-  actual: title.length
-})), Effect4.as({ ...d, title }));
-var setURLImpl = (url) => (d) => pipe2(Schema7.decodeUnknownEffect(UrlString)(url), Effect4.mapError(() => ValidationError.fromIssue("url", "Invalid URL", {
-  constraint: "URL",
-  expected: "valid URL",
-  actual: url
-})), Effect4.as({ ...d, url }));
-var setDescriptionImpl = (description) => (d) => pipe2(Schema7.decodeUnknownEffect(maxLength(4096))(description), Effect4.mapError(() => ValidationError.fromIssue("description", "Description must be 4096 characters or less", {
-  constraint: "MaxLength",
-  expected: "4096 characters or less",
-  actual: description.length
-})), Effect4.as({ ...d, description }));
-var setTimestampImpl = (date) => (d) => Effect4.succeed({ ...d, timestamp: (date ?? new Date).toISOString() });
-var setColorImpl = (color) => (d) => {
-  const colorValue = typeof color === "string" ? parseInt(color.replace("#", ""), 16) : color;
-  return pipe2(Schema7.decodeUnknownEffect(ColorCode)(colorValue), Effect4.mapError(() => ValidationError.fromIssue("color", "Invalid color code (must be 0-16777215)", {
-    constraint: "Range",
-    expected: "0-16777215",
-    actual: colorValue
-  })), Effect4.as({ ...d, color: colorValue }));
-};
-var setFooterImpl = (footerOrText, icon_url, proxy_icon_url) => (d) => {
-  const footer = typeof footerOrText === "string" ? {
-    text: footerOrText,
-    ...icon_url === undefined ? {} : { icon_url },
-    ...proxy_icon_url === undefined ? {} : { proxy_icon_url }
-  } : (() => {
-    const { text, icon_url: icon_url2, proxy_icon_url: proxy_icon_url2 } = footerOrText;
-    return {
-      text,
-      ...icon_url2 === undefined ? {} : { icon_url: icon_url2 },
-      ...proxy_icon_url2 === undefined ? {} : { proxy_icon_url: proxy_icon_url2 }
-    };
-  })();
-  return pipe2(Schema7.decodeUnknownEffect(Footer)(footer), Effect4.mapError((e) => ValidationError.fromParseError(e, { field: "footer", value: footer })), Effect4.as({ ...d, footer }));
-};
-var setImageImpl = (imageOrUrl, height, width) => (d) => {
-  const image = typeof imageOrUrl === "string" ? {
-    url: imageOrUrl,
-    ...height === undefined ? {} : { height },
-    ...width === undefined ? {} : { width }
-  } : (() => {
-    const { url, proxy_url, height: height2, width: width2 } = imageOrUrl;
-    return {
-      url,
-      ...proxy_url === undefined ? {} : { proxy_url },
-      ...height2 === undefined ? {} : { height: height2 },
-      ...width2 === undefined ? {} : { width: width2 }
-    };
-  })();
-  return pipe2(Schema7.decodeUnknownEffect(Image)(image), Effect4.mapError((e) => ValidationError.fromParseError(e, { field: "image", value: image })), Effect4.as({ ...d, image }));
-};
-var setThumbnailImpl = (thumbnailOrUrl, height, width) => (d) => {
-  const thumbnail = typeof thumbnailOrUrl === "string" ? {
-    url: thumbnailOrUrl,
-    ...height === undefined ? {} : { height },
-    ...width === undefined ? {} : { width }
-  } : (() => {
-    const { url, proxy_url, height: height2, width: width2 } = thumbnailOrUrl;
-    return {
-      url,
-      ...proxy_url === undefined ? {} : { proxy_url },
-      ...height2 === undefined ? {} : { height: height2 },
-      ...width2 === undefined ? {} : { width: width2 }
-    };
-  })();
-  return pipe2(Schema7.decodeUnknownEffect(Thumbnail)(thumbnail), Effect4.mapError((e) => ValidationError.fromParseError(e, {
-    field: "thumbnail",
-    value: thumbnail
-  })), Effect4.as({ ...d, thumbnail }));
-};
-var setVideoImpl = (videoOrUrl, height, width) => (d) => {
-  const video = typeof videoOrUrl === "string" ? {
-    url: videoOrUrl,
-    ...height === undefined ? {} : { height },
-    ...width === undefined ? {} : { width }
-  } : (() => {
-    const { url, proxy_url, height: height2, width: width2 } = videoOrUrl;
-    return {
-      ...url === undefined ? {} : { url },
-      ...proxy_url === undefined ? {} : { proxy_url },
-      ...height2 === undefined ? {} : { height: height2 },
-      ...width2 === undefined ? {} : { width: width2 }
-    };
-  })();
-  return pipe2(Schema7.decodeUnknownEffect(Video)(video), Effect4.mapError((e) => ValidationError.fromParseError(e, { field: "video", value: video })), Effect4.as({ ...d, video }));
-};
-var setProviderImpl = (providerOrName, url) => (d) => {
-  const provider = typeof providerOrName === "string" ? {
-    name: providerOrName,
-    ...url === undefined ? {} : { url }
-  } : (() => {
-    const { name, url: url2 } = providerOrName;
-    return {
-      ...name === undefined ? {} : { name },
-      ...url2 === undefined ? {} : { url: url2 }
-    };
-  })();
-  return pipe2(Schema7.decodeUnknownEffect(Provider)(provider), Effect4.mapError((e) => ValidationError.fromParseError(e, {
-    field: "provider",
-    value: provider
-  })), Effect4.as({ ...d, provider }));
-};
-var setAuthorImpl = (authorOrName, url, icon_url) => (d) => {
-  const author = typeof authorOrName === "string" ? {
-    name: authorOrName,
-    ...url === undefined ? {} : { url },
-    ...icon_url === undefined ? {} : { icon_url }
-  } : (() => {
-    const { name, url: url2, icon_url: icon_url2, proxy_icon_url } = authorOrName;
-    return {
-      ...name === undefined ? {} : { name },
-      ...url2 === undefined ? {} : { url: url2 },
-      ...icon_url2 === undefined ? {} : { icon_url: icon_url2 },
-      ...proxy_icon_url === undefined ? {} : { proxy_icon_url }
-    };
-  })();
-  return pipe2(Schema7.decodeUnknownEffect(Author)(author), Effect4.mapError((e) => ValidationError.fromParseError(e, { field: "author", value: author })), Effect4.as({ ...d, author }));
-};
-var addFieldImpl = (fieldOrName, value, inline = false) => (d) => {
-  const currentFields = d.fields || [];
-  if (currentFields.length >= 25) {
-    return Effect4.fail(ValidationError.fromIssue("fields", "Cannot add more than 25 fields", {
-      constraint: "MaxItems",
-      expected: "25 fields or less",
-      actual: currentFields.length + 1
-    }));
-  }
-  const field = typeof fieldOrName === "string" ? { name: fieldOrName, value: value ?? "", inline } : (() => {
-    const { name, value: value2, inline: inline2 } = fieldOrName;
-    return {
-      name,
-      value: value2,
-      ...inline2 === undefined ? {} : { inline: inline2 }
-    };
-  })();
-  return pipe2(Schema7.decodeUnknownEffect(Field)(field), Effect4.mapError((e) => ValidationError.fromParseError(e, { field: "fields", value: field })), Effect4.map(() => ({ ...d, fields: [...currentFields, field] })));
-};
-var setFieldsImpl = (fields) => (d) => {
-  if (fields.length > 25) {
-    return Effect4.fail(ValidationError.fromIssue("fields", "Cannot have more than 25 fields", {
-      constraint: "MaxItems",
-      expected: "25 fields or less",
-      actual: fields.length
-    }));
-  }
-  const normalized = fields.map((field) => {
-    const { name, value, inline } = field;
-    return {
-      name,
-      value,
-      ...inline === undefined ? {} : { inline }
-    };
-  });
-  return pipe2(Effect4.forEach(normalized, (f) => Schema7.decodeUnknownEffect(Field)(f)), Effect4.mapError((e) => ValidationError.fromParseError(e, { field: "fields", value: fields })), Effect4.map((decoded) => ({ ...d, fields: decoded })));
-};
-var buildImpl = (d) => pipe2(Schema7.decodeUnknownEffect(Embed)(stripUndefined({ ...d, type: "rich" })), Effect4.mapError((e) => ValidationError.fromParseError(e, { field: "embed", value: d })));
-var buildDirect = buildImpl;
-var addFieldDirect = addFieldImpl;
-var make = Effect4.succeed(createDraft());
-var chain = (f) => (self) => pipe2(self, Effect4.flatMap(f));
-var setTitle = (title) => chain(setTitleImpl(title));
-var setURL = (url) => chain(setURLImpl(url));
-var setDescription = (description) => chain(setDescriptionImpl(description));
-var setTimestamp = (date) => chain(setTimestampImpl(date));
-var setColor = (color) => chain(setColorImpl(color));
-var setFooter = (footer, icon_url, proxy_icon_url) => chain(setFooterImpl(footer, icon_url, proxy_icon_url));
-var setImage = (image, height, width) => chain(setImageImpl(image, height, width));
-var setThumbnail = (thumbnail, height, width) => chain(setThumbnailImpl(thumbnail, height, width));
-var setVideo = (video, height, width) => chain(setVideoImpl(video, height, width));
-var setProvider = (provider, url) => chain(setProviderImpl(provider, url));
-var setAuthor = (author, url, icon_url) => chain(setAuthorImpl(author, url, icon_url));
-var addField = (field, value, inline = false) => chain(addFieldImpl(field, value, inline));
-var setFields = (fields) => chain(setFieldsImpl(fields));
-var build = (self) => pipe2(self, Effect4.flatMap(buildImpl));
-// src/pipes/Webhook.ts
-var exports_Webhook = {};
-__export(exports_Webhook, {
-  validate: () => validate,
-  setUsername: () => setUsername,
-  setTTS: () => setTTS,
-  setFile: () => setFile,
-  setContent: () => setContent,
-  setAvatarUrl: () => setAvatarUrl,
-  modifyParams: () => modifyParams,
-  make: () => make2,
-  buildDirect: () => buildDirect2,
-  build: () => build2,
-  addEmbedImpl: () => addEmbedImpl,
-  addEmbedDirect: () => addEmbedDirect,
-  addEmbed: () => addEmbed
-});
-import { Effect as Effect5, pipe as pipe3, Schema as Schema8 } from "effect";
-var createDraft2 = () => ({});
-var setUsernameImpl = (username) => (d) => pipe3(Schema8.decodeUnknownEffect(maxLength(80))(username), Effect5.mapError(() => ValidationError.fromIssue("username", "Username must be 80 characters or less", {
-  constraint: "MaxLength",
-  expected: "80 characters or less",
-  actual: username.length
-})), Effect5.as({ ...d, username }));
-var setAvatarUrlImpl = (avatar_url) => (d) => pipe3(Schema8.decodeUnknownEffect(UrlString)(avatar_url), Effect5.mapError(() => ValidationError.fromIssue("avatar_url", "Invalid avatar URL", {
-  constraint: "URL",
-  expected: "valid URL",
-  actual: avatar_url
-})), Effect5.as({ ...d, avatar_url }));
-var setContentImpl = (content) => (d) => pipe3(Schema8.decodeUnknownEffect(maxLength(2000))(content), Effect5.mapError(() => ValidationError.fromIssue("content", "Content must be 2000 characters or less", {
-  constraint: "MaxLength",
-  expected: "2000 characters or less",
-  actual: content.length
-})), Effect5.as({ ...d, content }));
-var setTTSImpl = (tts) => (d) => Effect5.succeed({ ...d, tts });
-var addEmbedImpl = (embed) => (d) => {
-  const current = d.embeds || [];
-  const next = [...current, embed];
-  return pipe3(Schema8.decodeUnknownEffect(EmbedArray)(stripUndefined(next)), Effect5.mapError(() => ValidationError.fromIssue("embeds", "Cannot have more than 10 embeds", {
-    constraint: "MaxItems",
-    expected: "10 embeds or less",
-    actual: next.length
-  })), Effect5.map((decoded) => ({ ...d, embeds: decoded })));
-};
-var setFileImpl = (file) => (d) => Effect5.succeed({ ...d, file });
-var buildImpl2 = (d) => pipe3(Schema8.decodeUnknownEffect(Webhook)(stripUndefined(d)), Effect5.mapError((e) => ValidationError.fromParseError(e, { field: "webhook", value: d })));
-var buildDirect2 = buildImpl2;
-var addEmbedDirect = addEmbedImpl;
-var validate = (input) => pipe3(Schema8.decodeUnknownEffect(Webhook)(stripUndefined(input)), Effect5.mapError((e) => ValidationError.fromParseError(e, { field: "webhook", value: input })));
-var modifyParams = (p) => pipe3(Schema8.decodeUnknownEffect(WebhookParameter)(stripUndefined(p)), Effect5.mapError((e) => ValidationError.fromParseError(e, { field: "params", value: p })));
-var make2 = Effect5.succeed(createDraft2());
-var chain2 = (f) => (self) => pipe3(self, Effect5.flatMap(f));
-var setUsername = (username) => chain2(setUsernameImpl(username));
-var setAvatarUrl = (url) => chain2(setAvatarUrlImpl(url));
-var setContent = (content) => chain2(setContentImpl(content));
-var setTTS = (tts) => chain2(setTTSImpl(tts));
-var addEmbed = (embed) => chain2(addEmbedImpl(embed));
-var setFile = (file) => chain2(setFileImpl(file));
-var build2 = (self) => pipe3(self, Effect5.flatMap(buildImpl2));
 export {
   webhookErrorToLogObject,
   validateWebhook,
@@ -1145,7 +197,7 @@ export {
   WebhookParameter,
   WebhookFile,
   WebhookError,
-  exports_Webhook as Webhook,
+  Webhook2 as Webhook,
   Video,
   ValidationError,
   UrlString,
@@ -1166,7 +218,7 @@ export {
   Field,
   FetchHttpClient,
   EmbedArray,
-  exports_Embed as Embed,
+  Embed2 as Embed,
   DiscordWebhookUrl,
   DISCORD_WEBHOOK_REGEX,
   ConfigFromEnv,
@@ -1177,5 +229,5 @@ export {
   Attachment
 };
 
-//# debugId=484262147C37081864756E2164756E21
+//# debugId=77B5F8F8A236B81364756E2164756E21
 //# sourceMappingURL=index.js.map