@better-webhook/resend 0.1.1

package/dist/events.js

@@ -0,0 +1,258 @@
+import { defineEvent } from '@better-webhook/core';
+import { z } from 'zod';
+
+// src/events.ts
+var ResendTagsMapSchema = z.record(z.string(), z.string());
+var ResendEmailEventDataSchema = z.object({
+  broadcast_id: z.string().optional(),
+  created_at: z.string(),
+  email_id: z.string(),
+  from: z.string(),
+  to: z.array(z.string()),
+  subject: z.string(),
+  template_id: z.string().optional(),
+  tags: ResendTagsMapSchema.optional()
+}).passthrough();
+var ResendBounceSchema = z.object({
+  diagnosticCode: z.array(z.string()).optional(),
+  message: z.string(),
+  subType: z.string(),
+  type: z.string()
+}).passthrough();
+var ResendClickSchema = z.object({
+  ipAddress: z.string(),
+  link: z.string(),
+  timestamp: z.string(),
+  userAgent: z.string()
+}).passthrough();
+var ResendFailedSchema = z.object({
+  reason: z.string()
+}).passthrough();
+var ResendSuppressedSchema = z.object({
+  message: z.string(),
+  type: z.string()
+}).passthrough();
+var ResendReceivedAttachmentSchema = z.object({
+  id: z.string(),
+  filename: z.string().nullable(),
+  content_type: z.string(),
+  content_disposition: z.string().nullable(),
+  content_id: z.string().nullable()
+}).passthrough();
+var ResendReceivedEmailEventDataSchema = z.object({
+  email_id: z.string(),
+  created_at: z.string(),
+  from: z.string(),
+  to: z.array(z.string()),
+  bcc: z.array(z.string()).optional(),
+  cc: z.array(z.string()).optional(),
+  message_id: z.string(),
+  subject: z.string().default(""),
+  attachments: z.array(ResendReceivedAttachmentSchema).optional()
+}).passthrough();
+var ResendContactEventDataSchema = z.object({
+  id: z.string(),
+  audience_id: z.string().optional(),
+  segment_ids: z.array(z.string()),
+  created_at: z.string(),
+  updated_at: z.string(),
+  email: z.string(),
+  first_name: z.string().optional(),
+  last_name: z.string().optional(),
+  unsubscribed: z.boolean()
+}).passthrough();
+var ResendContactDeletedEventDataSchema = ResendContactEventDataSchema.extend(
+  {
+    segment_ids: z.array(z.string()).optional(),
+    unsubscribed: z.boolean().optional()
+  }
+).passthrough();
+var ResendDomainRecordSchema = z.object({
+  record: z.string(),
+  name: z.string(),
+  type: z.string(),
+  value: z.string(),
+  ttl: z.string(),
+  status: z.string(),
+  priority: z.number().optional()
+}).passthrough();
+var ResendDomainEventDataSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  status: z.string(),
+  created_at: z.string(),
+  region: z.string(),
+  records: z.array(ResendDomainRecordSchema)
+}).passthrough();
+function createResendEventSchema(eventType, dataSchema) {
+  return z.object({
+    type: z.literal(eventType),
+    created_at: z.string(),
+    data: dataSchema
+  }).passthrough();
+}
+var ResendEmailSentEventSchema = createResendEventSchema(
+  "email.sent",
+  ResendEmailEventDataSchema
+);
+var ResendEmailScheduledEventSchema = createResendEventSchema(
+  "email.scheduled",
+  ResendEmailEventDataSchema
+);
+var ResendEmailDeliveredEventSchema = createResendEventSchema(
+  "email.delivered",
+  ResendEmailEventDataSchema
+);
+var ResendEmailDeliveryDelayedEventSchema = createResendEventSchema(
+  "email.delivery_delayed",
+  ResendEmailEventDataSchema
+);
+var ResendEmailComplainedEventSchema = createResendEventSchema(
+  "email.complained",
+  ResendEmailEventDataSchema
+);
+var ResendEmailBouncedEventSchema = createResendEventSchema(
+  "email.bounced",
+  ResendEmailEventDataSchema.extend({
+    bounce: ResendBounceSchema
+  })
+);
+var ResendEmailOpenedEventSchema = createResendEventSchema(
+  "email.opened",
+  ResendEmailEventDataSchema
+);
+var ResendEmailClickedEventSchema = createResendEventSchema(
+  "email.clicked",
+  ResendEmailEventDataSchema.extend({
+    click: ResendClickSchema
+  })
+);
+var ResendEmailReceivedEventSchema = createResendEventSchema(
+  "email.received",
+  ResendReceivedEmailEventDataSchema
+);
+var ResendEmailFailedEventSchema = createResendEventSchema(
+  "email.failed",
+  ResendEmailEventDataSchema.extend({
+    failed: ResendFailedSchema
+  })
+);
+var ResendEmailSuppressedEventSchema = createResendEventSchema(
+  "email.suppressed",
+  ResendEmailEventDataSchema.extend({
+    suppressed: ResendSuppressedSchema
+  })
+);
+var ResendContactCreatedEventSchema = createResendEventSchema(
+  "contact.created",
+  ResendContactEventDataSchema
+);
+var ResendContactUpdatedEventSchema = createResendEventSchema(
+  "contact.updated",
+  ResendContactEventDataSchema
+);
+var ResendContactDeletedEventSchema = createResendEventSchema(
+  "contact.deleted",
+  ResendContactDeletedEventDataSchema
+);
+var ResendDomainCreatedEventSchema = createResendEventSchema(
+  "domain.created",
+  ResendDomainEventDataSchema
+);
+var ResendDomainUpdatedEventSchema = createResendEventSchema(
+  "domain.updated",
+  ResendDomainEventDataSchema
+);
+var ResendDomainDeletedEventSchema = createResendEventSchema(
+  "domain.deleted",
+  ResendDomainEventDataSchema
+);
+
+// src/events.ts
+var email_sent = defineEvent({
+  name: "email.sent",
+  schema: ResendEmailSentEventSchema,
+  provider: "resend"
+});
+var email_scheduled = defineEvent({
+  name: "email.scheduled",
+  schema: ResendEmailScheduledEventSchema,
+  provider: "resend"
+});
+var email_delivered = defineEvent({
+  name: "email.delivered",
+  schema: ResendEmailDeliveredEventSchema,
+  provider: "resend"
+});
+var email_delivery_delayed = defineEvent({
+  name: "email.delivery_delayed",
+  schema: ResendEmailDeliveryDelayedEventSchema,
+  provider: "resend"
+});
+var email_complained = defineEvent({
+  name: "email.complained",
+  schema: ResendEmailComplainedEventSchema,
+  provider: "resend"
+});
+var email_bounced = defineEvent({
+  name: "email.bounced",
+  schema: ResendEmailBouncedEventSchema,
+  provider: "resend"
+});
+var email_opened = defineEvent({
+  name: "email.opened",
+  schema: ResendEmailOpenedEventSchema,
+  provider: "resend"
+});
+var email_clicked = defineEvent({
+  name: "email.clicked",
+  schema: ResendEmailClickedEventSchema,
+  provider: "resend"
+});
+var email_received = defineEvent({
+  name: "email.received",
+  schema: ResendEmailReceivedEventSchema,
+  provider: "resend"
+});
+var email_failed = defineEvent({
+  name: "email.failed",
+  schema: ResendEmailFailedEventSchema,
+  provider: "resend"
+});
+var email_suppressed = defineEvent({
+  name: "email.suppressed",
+  schema: ResendEmailSuppressedEventSchema,
+  provider: "resend"
+});
+var contact_created = defineEvent({
+  name: "contact.created",
+  schema: ResendContactCreatedEventSchema,
+  provider: "resend"
+});
+var contact_updated = defineEvent({
+  name: "contact.updated",
+  schema: ResendContactUpdatedEventSchema,
+  provider: "resend"
+});
+var contact_deleted = defineEvent({
+  name: "contact.deleted",
+  schema: ResendContactDeletedEventSchema,
+  provider: "resend"
+});
+var domain_created = defineEvent({
+  name: "domain.created",
+  schema: ResendDomainCreatedEventSchema,
+  provider: "resend"
+});
+var domain_updated = defineEvent({
+  name: "domain.updated",
+  schema: ResendDomainUpdatedEventSchema,
+  provider: "resend"
+});
+var domain_deleted = defineEvent({
+  name: "domain.deleted",
+  schema: ResendDomainDeletedEventSchema,
+  provider: "resend"
+});
+
+export { contact_created, contact_deleted, contact_updated, domain_created, domain_deleted, domain_updated, email_bounced, email_clicked, email_complained, email_delivered, email_delivery_delayed, email_failed, email_opened, email_received, email_scheduled, email_sent, email_suppressed };

package/dist/index.cjs

@@ -0,0 +1,171 @@
+'use strict';
+
+var buffer = require('buffer');
+var crypto = require('crypto');
+var core = require('@better-webhook/core');
+
+// src/index.ts
+var DEFAULT_TIMESTAMP_TOLERANCE_SECONDS = 60 * 5;
+var WEBHOOK_SECRET_PREFIX = "whsec_";
+var STRICT_BASE64_PATTERN = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+var STRICT_BASE64_UNPADDED_PATTERN = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}|[A-Za-z0-9+/]{3})?$/;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeBody(rawBody) {
+  return typeof rawBody === "string" ? rawBody : rawBody.toString("utf-8");
+}
+function normalizeStrictBase64(value, options) {
+  if (value.length === 0) {
+    return void 0;
+  }
+  if (STRICT_BASE64_PATTERN.test(value)) {
+    return value;
+  }
+  if (!options?.allowUnpadded || !STRICT_BASE64_UNPADDED_PATTERN.test(value)) {
+    return void 0;
+  }
+  return value.padEnd(value.length + (4 - value.length % 4) % 4, "=");
+}
+function parseUnixTimestamp(value) {
+  if (!/^\d+$/.test(value)) {
+    return void 0;
+  }
+  const parsedTimestamp = Number(value);
+  if (!Number.isSafeInteger(parsedTimestamp) || parsedTimestamp <= 0) {
+    return void 0;
+  }
+  return parsedTimestamp;
+}
+function decodeWebhookSecret(secret) {
+  if (!secret.startsWith(WEBHOOK_SECRET_PREFIX)) {
+    return void 0;
+  }
+  const encodedSecret = secret.slice(WEBHOOK_SECRET_PREFIX.length);
+  const normalizedSecret = normalizeStrictBase64(encodedSecret, {
+    allowUnpadded: true
+  });
+  if (!normalizedSecret) {
+    return void 0;
+  }
+  try {
+    const decoded = buffer.Buffer.from(normalizedSecret, "base64");
+    if (decoded.length === 0) {
+      return void 0;
+    }
+    return decoded;
+  } catch {
+    return void 0;
+  }
+}
+function secureCompareBase64(left, right) {
+  const normalizedLeft = normalizeStrictBase64(left, { allowUnpadded: true });
+  const normalizedRight = normalizeStrictBase64(right, {
+    allowUnpadded: true
+  });
+  if (!normalizedLeft || !normalizedRight) {
+    return false;
+  }
+  try {
+    const leftBuffer = buffer.Buffer.from(normalizedLeft, "base64");
+    const rightBuffer = buffer.Buffer.from(normalizedRight, "base64");
+    if (leftBuffer.length !== rightBuffer.length) {
+      return false;
+    }
+    return crypto.timingSafeEqual(leftBuffer, rightBuffer);
+  } catch {
+    return false;
+  }
+}
+function parseSvixSignatures(signatureHeader) {
+  const signatures = [];
+  for (const versionedSignature of signatureHeader.split(" ")) {
+    const trimmedSegment = versionedSignature.trim();
+    if (!trimmedSegment) {
+      continue;
+    }
+    const [version, signature] = trimmedSegment.split(",", 2);
+    if (version === "v1" && signature) {
+      signatures.push(signature);
+    }
+  }
+  return signatures;
+}
+function extractReplayContext(headers) {
+  const replayKey = headers["svix-id"]?.trim();
+  const timestampHeader = headers["svix-timestamp"];
+  const timestamp = timestampHeader ? parseUnixTimestamp(timestampHeader) : void 0;
+  return {
+    replayKey: replayKey && replayKey.length > 0 ? replayKey : void 0,
+    timestamp
+  };
+}
+function verifyResendSignature(rawBody, headers, secret, timestampToleranceSeconds) {
+  const messageId = headers["svix-id"];
+  const messageTimestamp = headers["svix-timestamp"];
+  const signatureHeader = headers["svix-signature"];
+  if (!messageId || !messageTimestamp || !signatureHeader) {
+    return false;
+  }
+  const parsedTimestamp = parseUnixTimestamp(messageTimestamp);
+  if (!parsedTimestamp) {
+    return false;
+  }
+  const nowSeconds = Math.floor(Date.now() / 1e3);
+  const ageInSeconds = Math.abs(nowSeconds - parsedTimestamp);
+  if (timestampToleranceSeconds > 0 && ageInSeconds > timestampToleranceSeconds) {
+    return false;
+  }
+  const signingKey = decodeWebhookSecret(secret.trim());
+  if (!signingKey) {
+    return false;
+  }
+  const signatures = parseSvixSignatures(signatureHeader);
+  if (signatures.length === 0) {
+    return false;
+  }
+  const signedPayload = `${messageId}.${messageTimestamp}.${normalizeBody(rawBody)}`;
+  const expectedSignature = crypto.createHmac("sha256", signingKey).update(signedPayload).digest("base64");
+  for (const candidateSignature of signatures) {
+    if (secureCompareBase64(expectedSignature, candidateSignature)) {
+      return true;
+    }
+  }
+  return false;
+}
+function createResendProvider(options) {
+  const configuredTimestampTolerance = options?.timestampToleranceSeconds;
+  const timestampToleranceSeconds = configuredTimestampTolerance !== void 0 && Number.isFinite(configuredTimestampTolerance) ? configuredTimestampTolerance : DEFAULT_TIMESTAMP_TOLERANCE_SECONDS;
+  return {
+    name: "resend",
+    secret: options?.secret,
+    verification: "required",
+    verifiedUnhandledStatus: 200,
+    getEventType(_headers, body) {
+      if (!isRecord(body)) {
+        return void 0;
+      }
+      return typeof body.type === "string" ? body.type : void 0;
+    },
+    getDeliveryId(headers) {
+      return headers["svix-id"];
+    },
+    getReplayContext(headers) {
+      return extractReplayContext(headers);
+    },
+    verify(rawBody, headers, secret) {
+      return verifyResendSignature(
+        rawBody,
+        headers,
+        secret,
+        timestampToleranceSeconds
+      );
+    }
+  };
+}
+function resend(options) {
+  const provider = createResendProvider(options);
+  return new core.WebhookBuilder(provider);
+}
+
+exports.resend = resend;

package/dist/index.d.cts

@@ -0,0 +1,12 @@
+import { WebhookBuilder } from '@better-webhook/core';
+export { ResendContactCreatedEvent, ResendContactDeletedEvent, ResendContactUpdatedEvent, ResendDomainCreatedEvent, ResendDomainDeletedEvent, ResendDomainUpdatedEvent, ResendEmailBouncedEvent, ResendEmailClickedEvent, ResendEmailComplainedEvent, ResendEmailDeliveredEvent, ResendEmailDeliveryDelayedEvent, ResendEmailFailedEvent, ResendEmailOpenedEvent, ResendEmailReceivedEvent, ResendEmailScheduledEvent, ResendEmailSentEvent, ResendEmailSuppressedEvent, ResendProvider } from './events.cjs';
+import 'zod/v4/core';
+import 'zod';
+
+interface ResendOptions {
+    secret?: string;
+    timestampToleranceSeconds?: number;
+}
+declare function resend(options?: ResendOptions): WebhookBuilder<"resend">;
+
+export { type ResendOptions, resend };

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+import { WebhookBuilder } from '@better-webhook/core';
+export { ResendContactCreatedEvent, ResendContactDeletedEvent, ResendContactUpdatedEvent, ResendDomainCreatedEvent, ResendDomainDeletedEvent, ResendDomainUpdatedEvent, ResendEmailBouncedEvent, ResendEmailClickedEvent, ResendEmailComplainedEvent, ResendEmailDeliveredEvent, ResendEmailDeliveryDelayedEvent, ResendEmailFailedEvent, ResendEmailOpenedEvent, ResendEmailReceivedEvent, ResendEmailScheduledEvent, ResendEmailSentEvent, ResendEmailSuppressedEvent, ResendProvider } from './events.js';
+import 'zod/v4/core';
+import 'zod';
+
+interface ResendOptions {
+    secret?: string;
+    timestampToleranceSeconds?: number;
+}
+declare function resend(options?: ResendOptions): WebhookBuilder<"resend">;
+
+export { type ResendOptions, resend };

package/dist/index.js

@@ -0,0 +1,169 @@
+import { Buffer } from 'buffer';
+import { createHmac, timingSafeEqual } from 'crypto';
+import { WebhookBuilder } from '@better-webhook/core';
+
+// src/index.ts
+var DEFAULT_TIMESTAMP_TOLERANCE_SECONDS = 60 * 5;
+var WEBHOOK_SECRET_PREFIX = "whsec_";
+var STRICT_BASE64_PATTERN = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+var STRICT_BASE64_UNPADDED_PATTERN = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}|[A-Za-z0-9+/]{3})?$/;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeBody(rawBody) {
+  return typeof rawBody === "string" ? rawBody : rawBody.toString("utf-8");
+}
+function normalizeStrictBase64(value, options) {
+  if (value.length === 0) {
+    return void 0;
+  }
+  if (STRICT_BASE64_PATTERN.test(value)) {
+    return value;
+  }
+  if (!options?.allowUnpadded || !STRICT_BASE64_UNPADDED_PATTERN.test(value)) {
+    return void 0;
+  }
+  return value.padEnd(value.length + (4 - value.length % 4) % 4, "=");
+}
+function parseUnixTimestamp(value) {
+  if (!/^\d+$/.test(value)) {
+    return void 0;
+  }
+  const parsedTimestamp = Number(value);
+  if (!Number.isSafeInteger(parsedTimestamp) || parsedTimestamp <= 0) {
+    return void 0;
+  }
+  return parsedTimestamp;
+}
+function decodeWebhookSecret(secret) {
+  if (!secret.startsWith(WEBHOOK_SECRET_PREFIX)) {
+    return void 0;
+  }
+  const encodedSecret = secret.slice(WEBHOOK_SECRET_PREFIX.length);
+  const normalizedSecret = normalizeStrictBase64(encodedSecret, {
+    allowUnpadded: true
+  });
+  if (!normalizedSecret) {
+    return void 0;
+  }
+  try {
+    const decoded = Buffer.from(normalizedSecret, "base64");
+    if (decoded.length === 0) {
+      return void 0;
+    }
+    return decoded;
+  } catch {
+    return void 0;
+  }
+}
+function secureCompareBase64(left, right) {
+  const normalizedLeft = normalizeStrictBase64(left, { allowUnpadded: true });
+  const normalizedRight = normalizeStrictBase64(right, {
+    allowUnpadded: true
+  });
+  if (!normalizedLeft || !normalizedRight) {
+    return false;
+  }
+  try {
+    const leftBuffer = Buffer.from(normalizedLeft, "base64");
+    const rightBuffer = Buffer.from(normalizedRight, "base64");
+    if (leftBuffer.length !== rightBuffer.length) {
+      return false;
+    }
+    return timingSafeEqual(leftBuffer, rightBuffer);
+  } catch {
+    return false;
+  }
+}
+function parseSvixSignatures(signatureHeader) {
+  const signatures = [];
+  for (const versionedSignature of signatureHeader.split(" ")) {
+    const trimmedSegment = versionedSignature.trim();
+    if (!trimmedSegment) {
+      continue;
+    }
+    const [version, signature] = trimmedSegment.split(",", 2);
+    if (version === "v1" && signature) {
+      signatures.push(signature);
+    }
+  }
+  return signatures;
+}
+function extractReplayContext(headers) {
+  const replayKey = headers["svix-id"]?.trim();
+  const timestampHeader = headers["svix-timestamp"];
+  const timestamp = timestampHeader ? parseUnixTimestamp(timestampHeader) : void 0;
+  return {
+    replayKey: replayKey && replayKey.length > 0 ? replayKey : void 0,
+    timestamp
+  };
+}
+function verifyResendSignature(rawBody, headers, secret, timestampToleranceSeconds) {
+  const messageId = headers["svix-id"];
+  const messageTimestamp = headers["svix-timestamp"];
+  const signatureHeader = headers["svix-signature"];
+  if (!messageId || !messageTimestamp || !signatureHeader) {
+    return false;
+  }
+  const parsedTimestamp = parseUnixTimestamp(messageTimestamp);
+  if (!parsedTimestamp) {
+    return false;
+  }
+  const nowSeconds = Math.floor(Date.now() / 1e3);
+  const ageInSeconds = Math.abs(nowSeconds - parsedTimestamp);
+  if (timestampToleranceSeconds > 0 && ageInSeconds > timestampToleranceSeconds) {
+    return false;
+  }
+  const signingKey = decodeWebhookSecret(secret.trim());
+  if (!signingKey) {
+    return false;
+  }
+  const signatures = parseSvixSignatures(signatureHeader);
+  if (signatures.length === 0) {
+    return false;
+  }
+  const signedPayload = `${messageId}.${messageTimestamp}.${normalizeBody(rawBody)}`;
+  const expectedSignature = createHmac("sha256", signingKey).update(signedPayload).digest("base64");
+  for (const candidateSignature of signatures) {
+    if (secureCompareBase64(expectedSignature, candidateSignature)) {
+      return true;
+    }
+  }
+  return false;
+}
+function createResendProvider(options) {
+  const configuredTimestampTolerance = options?.timestampToleranceSeconds;
+  const timestampToleranceSeconds = configuredTimestampTolerance !== void 0 && Number.isFinite(configuredTimestampTolerance) ? configuredTimestampTolerance : DEFAULT_TIMESTAMP_TOLERANCE_SECONDS;
+  return {
+    name: "resend",
+    secret: options?.secret,
+    verification: "required",
+    verifiedUnhandledStatus: 200,
+    getEventType(_headers, body) {
+      if (!isRecord(body)) {
+        return void 0;
+      }
+      return typeof body.type === "string" ? body.type : void 0;
+    },
+    getDeliveryId(headers) {
+      return headers["svix-id"];
+    },
+    getReplayContext(headers) {
+      return extractReplayContext(headers);
+    },
+    verify(rawBody, headers, secret) {
+      return verifyResendSignature(
+        rawBody,
+        headers,
+        secret,
+        timestampToleranceSeconds
+      );
+    }
+  };
+}
+function resend(options) {
+  const provider = createResendProvider(options);
+  return new WebhookBuilder(provider);
+}
+
+export { resend };

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "@better-webhook/resend",
+  "version": "0.1.1",
+  "description": "Resend module for better-webhook",
+  "type": "module",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./events": {
+      "types": "./dist/events.d.ts",
+      "import": "./dist/events.js",
+      "require": "./dist/events.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "webhook",
+    "resend",
+    "email",
+    "webhook-handler",
+    "module",
+    "api"
+  ],
+  "license": "MIT",
+  "author": "Endalk <endalk200>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/endalk200/better-webhook.git",
+    "directory": "packages/resend"
+  },
+  "bugs": {
+    "url": "https://github.com/endalk200/better-webhook/issues"
+  },
+  "homepage": "https://github.com/endalk200/better-webhook#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "zod": "^4.0.0",
+    "@better-webhook/core": "0.11.4"
+  },
+  "peerDependencies": {},
+  "devDependencies": {
+    "@types/node": "^24.3.1",
+    "eslint": "^9.35.0",
+    "tsup": "^8.5.0",
+    "typescript": "^5.6.3",
+    "vitest": "^4.0.16",
+    "@better-webhook/eslint-config": "0.0.0",
+    "@better-webhook/typescript-config": "0.0.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "lint": "eslint .",
+    "check-types": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "clean": "rm -rf dist .turbo"
+  }
+}