@teever/ez-hook-effect 0.4.4 → 0.5.1

package/dist/index.js

@@ -55,28 +55,30 @@ var pathToString = (path) => {
   }, "$");
 };
 var toArray = (value) => Array.isArray(value) ? value : [value];
+var getIssueProp = (issue, key) => issue[key];
 var extractIssuesFromParseIssue = (issue, currentPath = []) => {
   const issues = [];
   switch (issue._tag) {
-    case "Type": {
-      const message = issue.message ?? `Expected ${issue.ast._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(issue.actual)
+        actual: truncateValue(getIssueProp(issue, "actual"))
       });
       break;
     }
     case "Forbidden": {
       issues.push({
         path: pathToString(currentPath),
-        message: issue.message ?? "Value is forbidden",
+        message: getIssueProp(issue, "message") ?? "Value is forbidden",
         constraint: "Forbidden"
       });
       break;
     }
-    case "Missing": {
+    case "MissingKey": {
       issues.push({
         path: pathToString(currentPath),
         message: "Required field is missing",
@@ -84,34 +86,60 @@ var extractIssuesFromParseIssue = (issue, currentPath = []) => {
       });
       break;
     }
-    case "Unexpected": {
+    case "UnexpectedKey": {
       issues.push({
         path: pathToString(currentPath),
-        message: issue.message ?? "Unexpected field",
+        message: getIssueProp(issue, "message") ?? "Unexpected field",
         constraint: "Unexpected",
-        actual: truncateValue(issue.actual)
+        actual: truncateValue(getIssueProp(issue, "actual"))
       });
       break;
     }
     case "Pointer": {
-      const pathSegments = toArray(issue.path);
+      const pathSegments = getIssueProp(issue, "path") ?? [];
       const newPath = [...currentPath, ...pathSegments];
-      issues.push(...extractIssuesFromParseIssue(issue.issue, newPath));
+      const nested = getIssueProp(issue, "issue");
+      if (nested)
+        issues.push(...extractIssuesFromParseIssue(nested, newPath));
       break;
     }
     case "Composite": {
-      const subIssues = toArray(issue.issues);
+      const rawIssues = getIssueProp(issue, "issues");
+      const subIssues = rawIssues ? toArray(rawIssues) : [];
       for (const subIssue of subIssues) {
         issues.push(...extractIssuesFromParseIssue(subIssue, currentPath));
       }
       break;
     }
-    case "Refinement": {
-      issues.push(...extractIssuesFromParseIssue(issue.issue, currentPath));
+    case "Filter":
+    case "Encoding": {
+      const nested = getIssueProp(issue, "issue");
+      if (nested)
+        issues.push(...extractIssuesFromParseIssue(nested, currentPath));
       break;
     }
-    case "Transformation": {
-      issues.push(...extractIssuesFromParseIssue(issue.issue, currentPath));
+    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;
     }
   }
@@ -187,18 +215,87 @@ 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 { Context, Effect, Config as EffectConfig, Layer } from "effect";
+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.pipe(Schema.pattern(DISCORD_WEBHOOK_REGEX, {
-  message: () => "Invalid Discord webhook URL"
+var DiscordWebhookUrl = Schema.String.check(Schema.isPattern(DISCORD_WEBHOOK_REGEX, {
+  message: "Invalid Discord webhook URL"
 }));
 
 // src/layers/Config.ts
-class Config extends Context.Tag("Config")() {
+class Config extends ServiceMap.Service()("Config") {
 }
 var validateWebhookUrl = (url) => {
   if (!url || url.trim() === "") {
@@ -289,16 +386,32 @@ var makeConfig = (webhookUrl, options) => Effect.gen(function* () {
 });
 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.
+  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"
-  })), 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));
+      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: {
@@ -322,8 +435,8 @@ var parseWebhookUrl = (url) => Effect.gen(function* () {
   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")() {
+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"];
@@ -376,13 +489,17 @@ var defaultRetryConfig = {
   jitter: true
 };
 var createRetrySchedule = (config) => {
+  const capDelay = (delay) => Duration.isLessThanOrEqualTo(delay, config.maxDelay) ? delay : config.maxDelay;
   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);
+    policy = policy.pipe(Schedule.modifyDelay((_, delay) => Effect2.sync(() => {
+      const millis = Duration.toMillis(delay);
+      return Duration.millis(millis + Math.random() * millis);
+    })));
   }
-  const capped = Schedule.intersect(policy, Schedule.recurs(config.maxRetries));
-  return capped.pipe(Schedule.map(([d]) => d));
+  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,
@@ -470,58 +587,42 @@ var FetchHttpClient = (retryConfig = defaultRetryConfig) => ({
 });
 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
+var makeTestHttpClient = (resolver, retryConfig = defaultRetryConfig) => Layer2.succeed(HttpClient, {
+  request: resolver,
+  retryConfig
 });
-import { Effect as Effect3, pipe, Schema as Schema6 } from "effect";
+// 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.pipe(Schema2.maxLength(max));
-var positiveInt = Schema2.Number.pipe(Schema2.int(), Schema2.positive());
-var UrlString = Schema2.String.pipe(Schema2.filter((s) => {
+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) => {
   try {
-    new URL(s);
+    new URL(value);
     return true;
   } catch {
-    return false;
+    return "Invalid URL format";
   }
-}, { message: () => "Invalid URL format" }), Schema2.annotations({
-  arbitrary: () => (fc) => fc.webUrl()
-}));
-var ISO8601Timestamp = Schema2.String.pipe(Schema2.filter((s) => {
+})));
+var ISO8601Timestamp = Schema2.String.pipe(Schema2.check(Schema2.makeFilter((value) => {
   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);
-  })
-}));
+  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);
 
 // src/schemas/Embed.ts
 import { Schema as Schema4 } from "effect";
@@ -531,222 +632,417 @@ import { Schema as Schema3 } from "effect";
 class Field extends Schema3.Class("Field")({
   name: maxLength(256),
   value: maxLength(1024),
-  inline: Schema3.optional(Schema3.Boolean)
+  inline: Schema3.optionalKey(Schema3.Boolean)
 }) {
 }
-var FieldArray = Schema3.Array(Field).pipe(Schema3.maxItems(25));
+var FieldArray = Schema3.Array(Field).pipe(Schema3.check(Schema3.isMaxLength(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)
+  proxyUrl: Schema4.optionalKey(Schema4.String),
+  filename: Schema4.optionalKey(Schema4.String),
+  size: Schema4.optionalKey(positiveInt),
+  height: Schema4.optionalKey(positiveInt),
+  width: Schema4.optionalKey(positiveInt)
 }) {
 }
-var UrlOrAttachment = Schema4.Union(UrlString, Attachment);
+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)
+  name: Schema4.optionalKey(maxLength(256)),
+  url: Schema4.optionalKey(UrlString),
+  icon_url: Schema4.optionalKey(UrlOrAttachment),
+  proxy_icon_url: Schema4.optionalKey(Schema4.String)
 }) {
 }
 
 class Footer extends Schema4.Class("Footer")({
   text: maxLength(2048),
-  icon_url: Schema4.optional(UrlOrAttachment),
-  proxy_icon_url: Schema4.optional(Schema4.String)
+  icon_url: Schema4.optionalKey(UrlOrAttachment),
+  proxy_icon_url: Schema4.optionalKey(Schema4.String)
 }) {
 }
 
 class Image extends Schema4.Class("Image")({
   url: UrlOrAttachment,
-  proxy_url: Schema4.optional(Schema4.String),
-  height: Schema4.optional(positiveInt),
-  width: Schema4.optional(positiveInt)
+  proxy_url: Schema4.optionalKey(Schema4.String),
+  height: Schema4.optionalKey(positiveInt),
+  width: Schema4.optionalKey(positiveInt)
 }) {
 }
 
 class Thumbnail extends Schema4.Class("Thumbnail")({
   url: UrlOrAttachment,
-  proxy_url: Schema4.optional(Schema4.String),
-  height: Schema4.optional(positiveInt),
-  width: Schema4.optional(positiveInt)
+  proxy_url: Schema4.optionalKey(Schema4.String),
+  height: Schema4.optionalKey(positiveInt),
+  width: Schema4.optionalKey(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)
+  url: Schema4.optionalKey(UrlString),
+  proxy_url: Schema4.optionalKey(Schema4.String),
+  height: Schema4.optionalKey(positiveInt),
+  width: Schema4.optionalKey(positiveInt)
 }) {
 }
 
 class Provider extends Schema4.Class("Provider")({
-  name: Schema4.optional(Schema4.String),
-  url: Schema4.optional(UrlString)
+  name: Schema4.optionalKey(Schema4.String),
+  url: Schema4.optionalKey(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)
+  title: Schema4.optionalKey(maxLength(256)),
+  type: Schema4.optionalKey(Schema4.Literal("rich")),
+  url: Schema4.optionalKey(UrlString),
+  description: Schema4.optionalKey(maxLength(4096)),
+  timestamp: Schema4.optionalKey(ISO8601Timestamp),
+  color: Schema4.optionalKey(ColorCode),
+  footer: Schema4.optionalKey(Footer),
+  image: Schema4.optionalKey(Image),
+  thumbnail: Schema4.optionalKey(Thumbnail),
+  video: Schema4.optionalKey(Video),
+  provider: Schema4.optionalKey(Provider),
+  author: Schema4.optionalKey(Author),
+  fields: Schema4.optionalKey(FieldArray)
 }) {
 }
-var EmbedArray = Schema4.Array(Embed).pipe(Schema4.maxItems(10));
+var EmbedArray = Schema4.Array(Embed).pipe(Schema4.check(Schema4.isMaxLength(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)
-}));
+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)
+  username: Schema5.optionalKey(maxLength(80)),
+  avatar_url: Schema5.optionalKey(UrlString),
+  tts: Schema5.optionalKey(Schema5.Boolean),
+  content: Schema5.optionalKey(maxLength(2000)),
+  file: Schema5.optionalKey(WebhookFile),
+  embeds: Schema5.optionalKey(EmbedArray)
 }) {
 }
 
 class WebhookParameter extends Schema5.Class("WebhookParameter")({
-  name: Schema5.optional(maxLength(80)),
-  avatar: Schema5.optional(UrlString),
-  channel_id: Schema5.optional(Schema5.String)
+  name: Schema5.optionalKey(maxLength(80)),
+  avatar: Schema5.optionalKey(UrlString),
+  channel_id: Schema5.optionalKey(Schema5.String)
 }) {
 }
 
 class WebhookResponse extends Schema5.Class("WebhookResponse")({
   id: Schema5.String,
   type: Schema5.Number,
-  guild_id: Schema5.optional(Schema5.String),
+  guild_id: Schema5.optionalKey(Schema5.String),
   channel_id: Schema5.String,
-  user: Schema5.optional(Schema5.Struct({
+  user: Schema5.optionalKey(Schema5.Struct({
     id: Schema5.String,
     username: Schema5.String,
-    avatar: Schema5.optional(Schema5.String),
+    avatar: Schema5.optionalKey(Schema5.String),
     discriminator: Schema5.String,
-    public_flags: Schema5.optional(Schema5.Number)
+    public_flags: Schema5.optionalKey(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({
+  name: Schema5.optionalKey(Schema5.String),
+  avatar: Schema5.optionalKey(Schema5.String),
+  token: Schema5.optionalKey(Schema5.String),
+  application_id: Schema5.optionalKey(Schema5.String),
+  source_guild: Schema5.optionalKey(Schema5.Struct({
     id: Schema5.String,
     name: Schema5.String,
-    icon: Schema5.optional(Schema5.String)
+    icon: Schema5.optionalKey(Schema5.String)
   })),
-  source_channel: Schema5.optional(Schema5.Struct({
+  source_channel: Schema5.optionalKey(Schema5.Struct({
     id: Schema5.String,
     name: Schema5.String
   })),
-  url: Schema5.optional(UrlString)
+  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) => pipe(Schema6.decodeUnknown(maxLength(256))(title), Effect3.mapError(() => ValidationError.fromIssue("title", "Title must be 256 characters or less", {
+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
-})), Effect3.as({ ...d, title }));
-var setURLImpl = (url) => (d) => pipe(Schema6.decodeUnknown(UrlString)(url), Effect3.mapError(() => ValidationError.fromIssue("url", "Invalid URL", {
+})), 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
-})), 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", {
+})), 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
-})), Effect3.as({ ...d, description }));
-var setTimestampImpl = (date) => (d) => Effect3.succeed({ ...d, timestamp: (date ?? new Date).toISOString() });
+})), 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 pipe(Schema6.decodeUnknown(ColorCode)(colorValue), Effect3.mapError(() => ValidationError.fromIssue("color", "Invalid color code (must be 0-16777215)", {
+  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
-  })), Effect3.as({ ...d, color: colorValue }));
+  })), Effect4.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 }));
+  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, width } : imageOrUrl;
-  return pipe(Schema6.decodeUnknown(Image)(image), Effect3.mapError((e) => ValidationError.fromParseError(e, { field: "image", value: image })), Effect3.as({ ...d, image }));
+  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, width } : thumbnailOrUrl;
-  return pipe(Schema6.decodeUnknown(Thumbnail)(thumbnail), Effect3.mapError((e) => ValidationError.fromParseError(e, {
+  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
-  })), Effect3.as({ ...d, thumbnail }));
+  })), Effect4.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 }));
+  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 } : providerOrName;
-  return pipe(Schema6.decodeUnknown(Provider)(provider), Effect3.mapError((e) => ValidationError.fromParseError(e, {
+  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
-  })), Effect3.as({ ...d, provider }));
+  })), Effect4.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 }));
+  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 Effect3.fail(ValidationError.fromIssue("fields", "Cannot add more than 25 fields", {
+    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 } : fieldOrName;
-  return pipe(Schema6.decodeUnknown(Field)(field), Effect3.mapError((e) => ValidationError.fromParseError(e, { field: "fields", value: field })), Effect3.map(() => ({ ...d, fields: [...currentFields, field] })));
+  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 Effect3.fail(ValidationError.fromIssue("fields", "Cannot have more than 25 fields", {
+    return Effect4.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] })));
+  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) => pipe(Schema6.decodeUnknown(Embed)({ ...d, type: "rich" }), Effect3.mapError((e) => ValidationError.fromParseError(e, { field: "embed", value: d })));
+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 = Effect3.succeed(createDraft());
-var chain = (f) => (self) => pipe(self, Effect3.flatMap(f));
+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));
@@ -760,10 +1056,11 @@ 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));
+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,
@@ -777,123 +1074,52 @@ __export(exports_Webhook, {
   addEmbedDirect: () => addEmbedDirect,
   addEmbed: () => addEmbed
 });
-import { Effect as Effect4, pipe as pipe2, Schema as Schema7 } from "effect";
+import { Effect as Effect5, pipe as pipe3, Schema as Schema8 } 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", {
+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
-})), Effect4.as({ ...d, username }));
-var setAvatarUrlImpl = (avatar_url) => (d) => pipe2(Schema7.decodeUnknown(UrlString)(avatar_url), Effect4.mapError(() => ValidationError.fromIssue("avatar_url", "Invalid avatar URL", {
+})), 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
-})), 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", {
+})), 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
-})), Effect4.as({ ...d, content }));
-var setTTSImpl = (tts) => (d) => Effect4.succeed({ ...d, tts });
+})), 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 pipe2(Schema7.decodeUnknown(EmbedArray)(next), Effect4.mapError(() => ValidationError.fromIssue("embeds", "Cannot have more than 10 embeds", {
+  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
-  })), Effect4.as({ ...d, embeds: next }));
+  })), Effect5.map((decoded) => ({ ...d, embeds: decoded })));
 };
-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 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 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 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) => 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());
+var build2 = (self) => pipe3(self, Effect5.flatMap(buildImpl2));
 export {
+  webhookErrorToLogObject,
   validateWebhook,
+  sendWebhookRaw,
   sendWebhook,
   positiveInt,
   parseWebhookUrl,
@@ -902,11 +1128,14 @@ export {
   modifyWebhook,
   maxLength,
   makeWebhookService,
+  makeTestHttpClient,
   makeIssue,
   makeHttpClientLayer,
+  makeDefaultLayer,
   makeConfigLayer,
   makeConfig,
   getWebhook,
+  formatWebhookError,
   deleteWebhook,
   defaultRetryConfig,
   createRetrySchedule,
@@ -948,5 +1177,5 @@ export {
   Attachment
 };
 
-//# debugId=8ED6FFCE1ADA022964756E2164756E21
+//# debugId=484262147C37081864756E2164756E21
 //# sourceMappingURL=index.js.map