@teever/ez-hook-effect 0.4.4

package/dist/index.js

@@ -0,0 +1,952 @@
+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 extractIssuesFromParseIssue = (issue, currentPath = []) => {
+  const issues = [];
+  switch (issue._tag) {
+    case "Type": {
+      const message = issue.message ?? `Expected ${issue.ast._tag}`;
+      issues.push({
+        path: pathToString(currentPath),
+        message,
+        constraint: extractConstraint(message) ?? "Type",
+        actual: truncateValue(issue.actual)
+      });
+      break;
+    }
+    case "Forbidden": {
+      issues.push({
+        path: pathToString(currentPath),
+        message: issue.message ?? "Value is forbidden",
+        constraint: "Forbidden"
+      });
+      break;
+    }
+    case "Missing": {
+      issues.push({
+        path: pathToString(currentPath),
+        message: "Required field is missing",
+        constraint: "Required"
+      });
+      break;
+    }
+    case "Unexpected": {
+      issues.push({
+        path: pathToString(currentPath),
+        message: issue.message ?? "Unexpected field",
+        constraint: "Unexpected",
+        actual: truncateValue(issue.actual)
+      });
+      break;
+    }
+    case "Pointer": {
+      const pathSegments = toArray(issue.path);
+      const newPath = [...currentPath, ...pathSegments];
+      issues.push(...extractIssuesFromParseIssue(issue.issue, newPath));
+      break;
+    }
+    case "Composite": {
+      const subIssues = toArray(issue.issues);
+      for (const subIssue of subIssues) {
+        issues.push(...extractIssuesFromParseIssue(subIssue, currentPath));
+      }
+      break;
+    }
+    case "Refinement": {
+      issues.push(...extractIssuesFromParseIssue(issue.issue, currentPath));
+      break;
+    }
+    case "Transformation": {
+      issues.push(...extractIssuesFromParseIssue(issue.issue, currentPath));
+      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") {
+}
+// src/layers/Config.ts
+import { Context, Effect, Config as EffectConfig, Layer } 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.pipe(Schema.pattern(DISCORD_WEBHOOK_REGEX, {
+  message: () => "Invalid Discord webhook URL"
+}));
+
+// src/layers/Config.ts
+class Config extends Context.Tag("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 webhookUrl = yield* EffectConfig.string("DISCORD_WEBHOOK_URL").pipe(Effect.mapError(() => 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"
+  })), Effect.flatMap(validateWebhookUrl));
+  const maxRetries = yield* EffectConfig.integer("WEBHOOK_MAX_RETRIES").pipe(EffectConfig.withDefault(3));
+  const baseDelayMs = yield* EffectConfig.integer("WEBHOOK_BASE_DELAY_MS").pipe(EffectConfig.withDefault(1000));
+  const maxDelayMs = yield* EffectConfig.integer("WEBHOOK_MAX_DELAY_MS").pipe(EffectConfig.withDefault(60000));
+  const enableJitter = yield* EffectConfig.boolean("WEBHOOK_ENABLE_JITTER").pipe(EffectConfig.withDefault(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 { Context as Context2, Duration, Effect as Effect2, Layer as Layer2, Schedule } from "effect";
+class HttpClient extends Context2.Tag("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) => {
+  let policy = Schedule.exponential(config.baseDelay, 2);
+  policy = policy.pipe(Schedule.delayed((d) => Duration.lessThanOrEqualTo(d, config.maxDelay) ? d : config.maxDelay));
+  if (config.jitter) {
+    policy = policy.pipe(Schedule.jittered);
+  }
+  const capped = Schedule.intersect(policy, Schedule.recurs(config.maxRetries));
+  return capped.pipe(Schedule.map(([d]) => d));
+};
+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 }));
+// 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 Effect3, pipe, Schema as Schema6 } from "effect";
+
+// src/schemas/Common.ts
+import { Schema as Schema2 } from "effect";
+var maxLength = (max) => Schema2.String.pipe(Schema2.maxLength(max));
+var positiveInt = Schema2.Number.pipe(Schema2.int(), Schema2.positive());
+var UrlString = Schema2.String.pipe(Schema2.filter((s) => {
+  try {
+    new URL(s);
+    return true;
+  } catch {
+    return false;
+  }
+}, { message: () => "Invalid URL format" }), Schema2.annotations({
+  arbitrary: () => (fc) => fc.webUrl()
+}));
+var ISO8601Timestamp = Schema2.String.pipe(Schema2.filter((s) => {
+  const iso8601Regex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z?$/;
+  return iso8601Regex.test(s);
+}, { message: () => "Invalid ISO8601 timestamp format" }), Schema2.annotations({
+  arbitrary: () => (fc) => fc.date().map((d) => d.toISOString())
+}));
+var ColorCode = Schema2.Number.pipe(Schema2.int(), Schema2.greaterThanOrEqualTo(0), Schema2.lessThanOrEqualTo(16777215));
+var Uint8ArraySchema = Schema2.instanceOf(Uint8Array).pipe(Schema2.annotations({
+  arbitrary: () => (fc) => fc.uint8Array().map((u8) => {
+    const ab = new ArrayBuffer(u8.byteLength);
+    new Uint8Array(ab).set(u8);
+    return new Uint8Array(ab);
+  })
+}));
+
+// src/schemas/Embed.ts
+import { Schema as Schema4 } from "effect";
+
+// src/schemas/Field.ts
+import { Schema as Schema3 } from "effect";
+class Field extends Schema3.Class("Field")({
+  name: maxLength(256),
+  value: maxLength(1024),
+  inline: Schema3.optional(Schema3.Boolean)
+}) {
+}
+var FieldArray = Schema3.Array(Field).pipe(Schema3.maxItems(25));
+
+// src/schemas/Embed.ts
+class Attachment extends Schema4.Class("Attachment")({
+  url: Schema4.String,
+  proxyUrl: Schema4.optional(Schema4.String),
+  filename: Schema4.optional(Schema4.String),
+  size: Schema4.optional(positiveInt),
+  height: Schema4.optional(positiveInt),
+  width: Schema4.optional(positiveInt)
+}) {
+}
+var UrlOrAttachment = Schema4.Union(UrlString, Attachment);
+
+class Author extends Schema4.Class("Author")({
+  name: Schema4.optional(maxLength(256)),
+  url: Schema4.optional(UrlString),
+  icon_url: Schema4.optional(UrlOrAttachment),
+  proxy_icon_url: Schema4.optional(Schema4.String)
+}) {
+}
+
+class Footer extends Schema4.Class("Footer")({
+  text: maxLength(2048),
+  icon_url: Schema4.optional(UrlOrAttachment),
+  proxy_icon_url: Schema4.optional(Schema4.String)
+}) {
+}
+
+class Image extends Schema4.Class("Image")({
+  url: UrlOrAttachment,
+  proxy_url: Schema4.optional(Schema4.String),
+  height: Schema4.optional(positiveInt),
+  width: Schema4.optional(positiveInt)
+}) {
+}
+
+class Thumbnail extends Schema4.Class("Thumbnail")({
+  url: UrlOrAttachment,
+  proxy_url: Schema4.optional(Schema4.String),
+  height: Schema4.optional(positiveInt),
+  width: Schema4.optional(positiveInt)
+}) {
+}
+
+class Video extends Schema4.Class("Video")({
+  url: Schema4.optional(UrlString),
+  proxy_url: Schema4.optional(Schema4.String),
+  height: Schema4.optional(positiveInt),
+  width: Schema4.optional(positiveInt)
+}) {
+}
+
+class Provider extends Schema4.Class("Provider")({
+  name: Schema4.optional(Schema4.String),
+  url: Schema4.optional(UrlString)
+}) {
+}
+
+class Embed extends Schema4.Class("Embed")({
+  title: Schema4.optional(maxLength(256)),
+  type: Schema4.optional(Schema4.Literal("rich")),
+  url: Schema4.optional(UrlString),
+  description: Schema4.optional(maxLength(4096)),
+  timestamp: Schema4.optional(ISO8601Timestamp),
+  color: Schema4.optional(ColorCode),
+  footer: Schema4.optional(Footer),
+  image: Schema4.optional(Image),
+  thumbnail: Schema4.optional(Thumbnail),
+  video: Schema4.optional(Video),
+  provider: Schema4.optional(Provider),
+  author: Schema4.optional(Author),
+  fields: Schema4.optional(FieldArray)
+}) {
+}
+var EmbedArray = Schema4.Array(Embed).pipe(Schema4.maxItems(10));
+
+// src/schemas/Webhook.ts
+import { Schema as Schema5 } from "effect";
+var WebhookFile = Schema5.Union(Schema5.String, Attachment, Schema5.Struct({
+  name: Schema5.String,
+  data: Schema5.Union(Schema5.String, Uint8ArraySchema)
+}));
+
+class Webhook extends Schema5.Class("Webhook")({
+  username: Schema5.optional(maxLength(80)),
+  avatar_url: Schema5.optional(UrlString),
+  tts: Schema5.optional(Schema5.Boolean),
+  content: Schema5.optional(maxLength(2000)),
+  file: Schema5.optional(WebhookFile),
+  embeds: Schema5.optional(EmbedArray)
+}) {
+}
+
+class WebhookParameter extends Schema5.Class("WebhookParameter")({
+  name: Schema5.optional(maxLength(80)),
+  avatar: Schema5.optional(UrlString),
+  channel_id: Schema5.optional(Schema5.String)
+}) {
+}
+
+class WebhookResponse extends Schema5.Class("WebhookResponse")({
+  id: Schema5.String,
+  type: Schema5.Number,
+  guild_id: Schema5.optional(Schema5.String),
+  channel_id: Schema5.String,
+  user: Schema5.optional(Schema5.Struct({
+    id: Schema5.String,
+    username: Schema5.String,
+    avatar: Schema5.optional(Schema5.String),
+    discriminator: Schema5.String,
+    public_flags: Schema5.optional(Schema5.Number)
+  })),
+  name: Schema5.optional(Schema5.String),
+  avatar: Schema5.optional(Schema5.String),
+  token: Schema5.optional(Schema5.String),
+  application_id: Schema5.optional(Schema5.String),
+  source_guild: Schema5.optional(Schema5.Struct({
+    id: Schema5.String,
+    name: Schema5.String,
+    icon: Schema5.optional(Schema5.String)
+  })),
+  source_channel: Schema5.optional(Schema5.Struct({
+    id: Schema5.String,
+    name: Schema5.String
+  })),
+  url: Schema5.optional(UrlString)
+}) {
+}
+
+// src/pipes/Embed.ts
+var createDraft = () => ({});
+var setTitleImpl = (title) => (d) => pipe(Schema6.decodeUnknown(maxLength(256))(title), Effect3.mapError(() => ValidationError.fromIssue("title", "Title must be 256 characters or less", {
+  constraint: "MaxLength",
+  expected: "256 characters or less",
+  actual: title.length
+})), Effect3.as({ ...d, title }));
+var setURLImpl = (url) => (d) => pipe(Schema6.decodeUnknown(UrlString)(url), Effect3.mapError(() => ValidationError.fromIssue("url", "Invalid URL", {
+  constraint: "URL",
+  expected: "valid URL",
+  actual: url
+})), Effect3.as({ ...d, url }));
+var setDescriptionImpl = (description) => (d) => pipe(Schema6.decodeUnknown(maxLength(4096))(description), Effect3.mapError(() => ValidationError.fromIssue("description", "Description must be 4096 characters or less", {
+  constraint: "MaxLength",
+  expected: "4096 characters or less",
+  actual: description.length
+})), Effect3.as({ ...d, description }));
+var setTimestampImpl = (date) => (d) => Effect3.succeed({ ...d, timestamp: (date ?? new Date).toISOString() });
+var setColorImpl = (color) => (d) => {
+  const colorValue = typeof color === "string" ? parseInt(color.replace("#", ""), 16) : color;
+  return pipe(Schema6.decodeUnknown(ColorCode)(colorValue), Effect3.mapError(() => ValidationError.fromIssue("color", "Invalid color code (must be 0-16777215)", {
+    constraint: "Range",
+    expected: "0-16777215",
+    actual: colorValue
+  })), Effect3.as({ ...d, color: colorValue }));
+};
+var setFooterImpl = (footerOrText, icon_url, proxy_icon_url) => (d) => {
+  const footer = typeof footerOrText === "string" ? { text: footerOrText, icon_url, proxy_icon_url } : footerOrText;
+  return pipe(Schema6.decodeUnknown(Footer)(footer), Effect3.mapError((e) => ValidationError.fromParseError(e, { field: "footer", value: footer })), Effect3.as({ ...d, footer }));
+};
+var setImageImpl = (imageOrUrl, height, width) => (d) => {
+  const image = typeof imageOrUrl === "string" ? { url: imageOrUrl, height, width } : imageOrUrl;
+  return pipe(Schema6.decodeUnknown(Image)(image), Effect3.mapError((e) => ValidationError.fromParseError(e, { field: "image", value: image })), Effect3.as({ ...d, image }));
+};
+var setThumbnailImpl = (thumbnailOrUrl, height, width) => (d) => {
+  const thumbnail = typeof thumbnailOrUrl === "string" ? { url: thumbnailOrUrl, height, width } : thumbnailOrUrl;
+  return pipe(Schema6.decodeUnknown(Thumbnail)(thumbnail), Effect3.mapError((e) => ValidationError.fromParseError(e, {
+    field: "thumbnail",
+    value: thumbnail
+  })), Effect3.as({ ...d, thumbnail }));
+};
+var setVideoImpl = (videoOrUrl, height, width) => (d) => {
+  const video = typeof videoOrUrl === "string" ? { url: videoOrUrl, height, width } : videoOrUrl;
+  return pipe(Schema6.decodeUnknown(Video)(video), Effect3.mapError((e) => ValidationError.fromParseError(e, { field: "video", value: video })), Effect3.as({ ...d, video }));
+};
+var setProviderImpl = (providerOrName, url) => (d) => {
+  const provider = typeof providerOrName === "string" ? { name: providerOrName, url } : providerOrName;
+  return pipe(Schema6.decodeUnknown(Provider)(provider), Effect3.mapError((e) => ValidationError.fromParseError(e, {
+    field: "provider",
+    value: provider
+  })), Effect3.as({ ...d, provider }));
+};
+var setAuthorImpl = (authorOrName, url, icon_url) => (d) => {
+  const author = typeof authorOrName === "string" ? { name: authorOrName, url, icon_url } : authorOrName;
+  return pipe(Schema6.decodeUnknown(Author)(author), Effect3.mapError((e) => ValidationError.fromParseError(e, { field: "author", value: author })), Effect3.as({ ...d, author }));
+};
+var addFieldImpl = (fieldOrName, value, inline = false) => (d) => {
+  const currentFields = d.fields || [];
+  if (currentFields.length >= 25) {
+    return Effect3.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 } : fieldOrName;
+  return pipe(Schema6.decodeUnknown(Field)(field), Effect3.mapError((e) => ValidationError.fromParseError(e, { field: "fields", value: field })), Effect3.map(() => ({ ...d, fields: [...currentFields, field] })));
+};
+var setFieldsImpl = (fields) => (d) => {
+  if (fields.length > 25) {
+    return Effect3.fail(ValidationError.fromIssue("fields", "Cannot have more than 25 fields", {
+      constraint: "MaxItems",
+      expected: "25 fields or less",
+      actual: fields.length
+    }));
+  }
+  return pipe(Effect3.forEach(fields, (f) => Schema6.decodeUnknown(Field)(f)), Effect3.mapError((e) => ValidationError.fromParseError(e, { field: "fields", value: fields })), Effect3.map(() => ({ ...d, fields: [...fields] })));
+};
+var buildImpl = (d) => pipe(Schema6.decodeUnknown(Embed)({ ...d, type: "rich" }), Effect3.mapError((e) => ValidationError.fromParseError(e, { field: "embed", value: d })));
+var buildDirect = buildImpl;
+var addFieldDirect = addFieldImpl;
+var make = Effect3.succeed(createDraft());
+var chain = (f) => (self) => pipe(self, Effect3.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) => pipe(self, Effect3.flatMap(buildImpl));
+// src/pipes/Webhook.ts
+var exports_Webhook = {};
+__export(exports_Webhook, {
+  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 Effect4, pipe as pipe2, Schema as Schema7 } from "effect";
+var createDraft2 = () => ({});
+var setUsernameImpl = (username) => (d) => pipe2(Schema7.decodeUnknown(maxLength(80))(username), Effect4.mapError(() => ValidationError.fromIssue("username", "Username must be 80 characters or less", {
+  constraint: "MaxLength",
+  expected: "80 characters or less",
+  actual: username.length
+})), Effect4.as({ ...d, username }));
+var setAvatarUrlImpl = (avatar_url) => (d) => pipe2(Schema7.decodeUnknown(UrlString)(avatar_url), Effect4.mapError(() => ValidationError.fromIssue("avatar_url", "Invalid avatar URL", {
+  constraint: "URL",
+  expected: "valid URL",
+  actual: avatar_url
+})), Effect4.as({ ...d, avatar_url }));
+var setContentImpl = (content) => (d) => pipe2(Schema7.decodeUnknown(maxLength(2000))(content), Effect4.mapError(() => ValidationError.fromIssue("content", "Content must be 2000 characters or less", {
+  constraint: "MaxLength",
+  expected: "2000 characters or less",
+  actual: content.length
+})), Effect4.as({ ...d, content }));
+var setTTSImpl = (tts) => (d) => Effect4.succeed({ ...d, tts });
+var addEmbedImpl = (embed) => (d) => {
+  const current = d.embeds || [];
+  const next = [...current, embed];
+  return pipe2(Schema7.decodeUnknown(EmbedArray)(next), Effect4.mapError(() => ValidationError.fromIssue("embeds", "Cannot have more than 10 embeds", {
+    constraint: "MaxItems",
+    expected: "10 embeds or less",
+    actual: next.length
+  })), Effect4.as({ ...d, embeds: next }));
+};
+var setFileImpl = (file) => (d) => Effect4.succeed({ ...d, file });
+var buildImpl2 = (d) => pipe2(Schema7.decodeUnknown(Webhook)(d), Effect4.mapError((e) => ValidationError.fromParseError(e, { field: "webhook", value: d })));
+var buildDirect2 = buildImpl2;
+var addEmbedDirect = addEmbedImpl;
+var modifyParams = (p) => pipe2(Schema7.decodeUnknown(WebhookParameter)(p), Effect4.mapError((e) => ValidationError.fromParseError(e, { field: "params", value: p })));
+var make2 = Effect4.succeed(createDraft2());
+var chain2 = (f) => (self) => pipe2(self, Effect4.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) => pipe2(self, Effect4.flatMap(buildImpl2));
+// src/services/WebhookService.ts
+import {
+  Context as Context3,
+  Duration as Duration2,
+  Effect as Effect5,
+  Layer as Layer3,
+  pipe as pipe3,
+  Schedule as Schedule2,
+  Schema as Schema8
+} from "effect";
+class WebhookService extends Context3.Tag("WebhookService")() {
+}
+var makeWebhookService = Effect5.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 sendWebhook = (webhook) => pipe3(Schema8.decodeUnknown(Webhook)(webhook), Effect5.mapError((e) => ValidationError.fromParseError(e, { field: "webhook", value: webhook })), Effect5.flatMap((validatedWebhook) => httpClient.request({
+    method: "POST",
+    url: webhookUrl,
+    body: validatedWebhook
+  }).pipe(Effect5.retry(retrySchedule.pipe(Schedule2.whileInput((error) => {
+    if (error instanceof NetworkError)
+      return true;
+    if (error instanceof RateLimitError)
+      return true;
+    if (error instanceof HttpError) {
+      const status = error.response?.status;
+      return typeof status === "number" && status >= 500;
+    }
+    return false;
+  }))))), Effect5.map((response) => response.status === 204 && response.text === ""));
+  const modifyWebhook = (params) => pipe3(Schema8.decodeUnknown(WebhookParameter)(params), Effect5.mapError((e) => ValidationError.fromParseError(e, { field: "params", value: params })), Effect5.flatMap((validatedParams) => httpClient.request({
+    method: "PATCH",
+    url: webhookUrl,
+    body: validatedParams
+  })), Effect5.flatMap((response) => Schema8.decodeUnknown(WebhookResponse)(response.body).pipe(Effect5.mapError(() => new WebhookError({
+    message: "Invalid webhook response",
+    cause: response.body
+  })))));
+  const getWebhook = () => pipe3(httpClient.request({
+    method: "GET",
+    url: webhookUrl
+  }), Effect5.flatMap((response) => Schema8.decodeUnknown(WebhookResponse)(response.body).pipe(Effect5.mapError(() => new WebhookError({
+    message: "Invalid webhook response",
+    cause: response.body
+  })))));
+  const validateWebhook = () => pipe3(httpClient.request({
+    method: "GET",
+    url: webhookUrl
+  }), Effect5.as(true), Effect5.catchAll(() => Effect5.succeed(false)));
+  const deleteWebhook = () => pipe3(httpClient.request({
+    method: "DELETE",
+    url: webhookUrl
+  }), Effect5.map((response) => response.status === 204));
+  return {
+    sendWebhook,
+    modifyWebhook,
+    getWebhook,
+    deleteWebhook,
+    validateWebhook
+  };
+});
+var WebhookServiceLive = Layer3.effect(WebhookService, makeWebhookService);
+var sendWebhook = (webhook) => Effect5.flatMap(WebhookService, (service) => service.sendWebhook(webhook));
+var modifyWebhook = (params) => Effect5.flatMap(WebhookService, (service) => service.modifyWebhook(params));
+var getWebhook = () => Effect5.flatMap(WebhookService, (service) => service.getWebhook());
+var deleteWebhook = () => Effect5.flatMap(WebhookService, (service) => service.deleteWebhook());
+var validateWebhook = () => Effect5.flatMap(WebhookService, (service) => service.validateWebhook());
+export {
+  validateWebhook,
+  sendWebhook,
+  positiveInt,
+  parseWebhookUrl,
+  parseRateLimitHeaders,
+  parseErrorToIssues,
+  modifyWebhook,
+  maxLength,
+  makeWebhookService,
+  makeIssue,
+  makeHttpClientLayer,
+  makeConfigLayer,
+  makeConfig,
+  getWebhook,
+  deleteWebhook,
+  defaultRetryConfig,
+  createRetrySchedule,
+  WebhookServiceLive,
+  WebhookService,
+  WebhookResponse,
+  WebhookParameter,
+  WebhookFile,
+  WebhookError,
+  exports_Webhook as Webhook,
+  Video,
+  ValidationError,
+  UrlString,
+  UrlOrAttachment,
+  Uint8ArraySchema,
+  Thumbnail,
+  RateLimitError,
+  Provider,
+  NetworkError,
+  Image,
+  ISO8601Timestamp,
+  HttpError,
+  HttpClientLive,
+  HttpClient,
+  Footer,
+  FileError,
+  FieldArray,
+  Field,
+  FetchHttpClient,
+  EmbedArray,
+  exports_Embed as Embed,
+  DiscordWebhookUrl,
+  DISCORD_WEBHOOK_REGEX,
+  ConfigFromEnv,
+  ConfigError,
+  Config,
+  ColorCode,
+  Author,
+  Attachment
+};
+
+//# debugId=8ED6FFCE1ADA022964756E2164756E21
+//# sourceMappingURL=index.js.map