@critical-path/core 0.36.0 → 0.36.1

package/src/utils/workflow.ts

@@ -1,306 +0,0 @@
-import type {
-  Workflow,
-  StatusDefinition,
-  TaskTypeDefinition
-} from '../types/index.js';
-import { DEFAULT_STATUS_DEFINITIONS } from './status.js';
-
-export class WorkflowValidationError extends Error {
-  public readonly fromStatus: string;
-  public readonly toStatus: string;
-  public readonly workflowId?: string;
-
-  constructor(fromStatus: string, toStatus: string, workflowId?: string, message?: string) {
-    const msg = message || `Illegal status transition from "${fromStatus}" to "${toStatus}"${workflowId ? ` in workflow "${workflowId}"` : ''}.`;
-    super(msg);
-    this.name = 'WorkflowValidationError';
-    this.fromStatus = fromStatus;
-    this.toStatus = toStatus;
-    this.workflowId = workflowId;
-  }
-}
-
-export const DEFAULT_TASK_TYPES: TaskTypeDefinition[] = [
-  { key: 'task', label: 'Task', description: 'A standard work item', icon: 'check-square' },
-  { key: 'bug', label: 'Bug', description: 'A problem or defect that needs fixing', icon: 'bug' },
-  { key: 'feature', label: 'Feature', description: 'A new capability or enhancement', icon: 'sparkles' },
-  { key: 'epic', label: 'Epic', description: 'A large body of work that spans multiple tasks', icon: 'layers' },
-  { key: 'subtask', label: 'Subtask', description: 'A piece of work required to complete a parent task', icon: 'corner-down-right' }
-];
-
-export const DEFAULT_SOFTWARE_WORKFLOW: Workflow = {
-  id: 'wf_software_default',
-  name: 'Software Development Workflow',
-  description: 'Standard software development lifecycle with backlog, review, and completion states.',
-  statuses: [
-    DEFAULT_STATUS_DEFINITIONS.backlog,
-    DEFAULT_STATUS_DEFINITIONS.todo,
-    DEFAULT_STATUS_DEFINITIONS.in_progress,
-    DEFAULT_STATUS_DEFINITIONS.in_review,
-    DEFAULT_STATUS_DEFINITIONS.done,
-    DEFAULT_STATUS_DEFINITIONS.canceled
-  ],
-  transitions: [
-    { name: 'Start Work', fromStatusKey: 'backlog', toStatusKey: 'todo' },
-    { name: 'Return to Backlog', fromStatusKey: 'todo', toStatusKey: 'backlog' },
-    { name: 'Start Implementation', fromStatusKey: 'todo', toStatusKey: 'in_progress' },
-    { name: 'Return to To Do', fromStatusKey: 'in_progress', toStatusKey: 'todo' },
-    { name: 'Complete Task', fromStatusKey: 'todo', toStatusKey: 'done' },
-    { name: 'Submit for Review', fromStatusKey: 'in_progress', toStatusKey: 'in_review' },
-    { name: 'Complete Implementation', fromStatusKey: 'in_progress', toStatusKey: 'done' },
-    { name: 'Approve & Complete', fromStatusKey: 'in_review', toStatusKey: 'done' },
-    { name: 'Request Changes', fromStatusKey: 'in_review', toStatusKey: 'in_progress' },
-    { name: 'Reopen', fromStatusKey: 'done', toStatusKey: 'todo' },
-    { name: 'Cancel', fromStatusKey: '*', toStatusKey: 'canceled' },
-    { name: 'Restore', fromStatusKey: 'canceled', toStatusKey: 'todo' }
-  ],
-  taskTypes: DEFAULT_TASK_TYPES,
-  defaultStatusKey: 'todo',
-  isDefault: false,
-  createdAt: '2026-01-01T00:00:00.000Z',
-  updatedAt: '2026-01-01T00:00:00.000Z'
-};
-
-export const DEFAULT_SIMPLE_WORKFLOW: Workflow = {
-  id: 'wf_simple_default',
-  name: 'Simple Task Workflow',
-  description: 'Lightweight workflow with To Do, In Progress, and Done states.',
-  statuses: [
-    DEFAULT_STATUS_DEFINITIONS.todo,
-    DEFAULT_STATUS_DEFINITIONS.in_progress,
-    DEFAULT_STATUS_DEFINITIONS.done
-  ],
-  transitions: [
-    { name: 'Start', fromStatusKey: 'todo', toStatusKey: 'in_progress' },
-    { name: 'Return to To Do', fromStatusKey: 'in_progress', toStatusKey: 'todo' },
-    { name: 'Complete', fromStatusKey: 'todo', toStatusKey: 'done' },
-    { name: 'Complete', fromStatusKey: 'in_progress', toStatusKey: 'done' },
-    { name: 'Reopen', fromStatusKey: 'done', toStatusKey: 'todo' },
-    { name: 'Return to In Progress', fromStatusKey: 'done', toStatusKey: 'in_progress' }
-  ],
-  taskTypes: DEFAULT_TASK_TYPES.filter((t) => ['task', 'subtask'].includes(t.key)),
-  defaultStatusKey: 'todo',
-  isDefault: true,
-  createdAt: '2026-01-01T00:00:00.000Z',
-  updatedAt: '2026-01-01T00:00:00.000Z'
-};
-
-export const DEFAULT_VFX_WORKFLOW: Workflow = {
-  id: 'wf_vfx_default',
-  name: 'VFX Production Workflow',
-  description: 'Visual effects production pipeline from bidding and drafting to internal lead review and client supervisor approval.',
-  statuses: [
-    { key: 'bidding', label: 'Bidding & Draft', category: 'not_started' },
-    { key: 'awarded', label: 'Awarded / Ready', category: 'not_started' },
-    { key: 'in_production', label: 'In Production', category: 'in_progress' },
-    { key: 'internal_review', label: 'Internal Review', category: 'in_progress' },
-    { key: 'client_review', label: 'Client Review', category: 'in_progress' },
-    { key: 'revision_requested', label: 'Revision Requested', category: 'in_progress' },
-    { key: 'approved', label: 'Approved (Final)', category: 'completed' },
-    DEFAULT_STATUS_DEFINITIONS.canceled
-  ],
-  transitions: [
-    { name: 'Award Bid', fromStatusKey: 'bidding', toStatusKey: 'awarded' },
-    { name: 'Start Directly from Bid', fromStatusKey: 'bidding', toStatusKey: 'in_production' },
-    { name: 'Start Work', fromStatusKey: 'awarded', toStatusKey: 'in_production' },
-    { name: 'Reopen Bid', fromStatusKey: 'awarded', toStatusKey: 'bidding' },
-    { name: 'Submit to Lead Review', fromStatusKey: 'in_production', toStatusKey: 'internal_review' },
-    { name: 'Fast-Track Client Review', fromStatusKey: 'in_production', toStatusKey: 'client_review' },
-    { name: 'Direct Approval', fromStatusKey: 'in_production', toStatusKey: 'approved' },
-    { name: 'Submit to Client Review', fromStatusKey: 'internal_review', toStatusKey: 'client_review' },
-    { name: 'Request Internal Revisions', fromStatusKey: 'internal_review', toStatusKey: 'revision_requested' },
-    { name: 'Return to Production', fromStatusKey: 'internal_review', toStatusKey: 'in_production' },
-    { name: 'Approve from Lead Review', fromStatusKey: 'internal_review', toStatusKey: 'approved' },
-    { name: 'Request Client Revisions', fromStatusKey: 'client_review', toStatusKey: 'revision_requested' },
-    { name: 'Return to Lead Review', fromStatusKey: 'client_review', toStatusKey: 'internal_review' },
-    { name: 'Approve Final Shot', fromStatusKey: 'client_review', toStatusKey: 'approved' },
-    { name: 'Address Revisions in Production', fromStatusKey: 'revision_requested', toStatusKey: 'in_production' },
-    { name: 'Resubmit to Lead Review', fromStatusKey: 'revision_requested', toStatusKey: 'internal_review' },
-    { name: 'Resubmit to Client Review', fromStatusKey: 'revision_requested', toStatusKey: 'client_review' },
-    { name: 'Reopen Shot', fromStatusKey: 'approved', toStatusKey: 'in_production' },
-    { name: 'Reopen Lead Review', fromStatusKey: 'approved', toStatusKey: 'internal_review' },
-    { name: 'Cancel', fromStatusKey: '*', toStatusKey: 'canceled' },
-    { name: 'Restore to Bidding', fromStatusKey: 'canceled', toStatusKey: 'bidding' },
-    { name: 'Restore to Production', fromStatusKey: 'canceled', toStatusKey: 'in_production' }
-  ],
-  taskTypes: [
-    { key: 'vfx_task', label: 'VFX Task', description: 'Department task (e.g. Matchmove, Animation, FX, Comp)', icon: 'film' },
-    { key: 'asset', label: 'Asset', description: '3D or 2D asset element', icon: 'box' },
-    { key: 'subtask', label: 'Subtask', description: 'Element subtask required to complete a department task', icon: 'corner-down-right' }
-  ],
-  defaultStatusKey: 'bidding',
-  isDefault: false,
-  createdAt: '2026-01-01T00:00:00.000Z',
-  updatedAt: '2026-01-01T00:00:00.000Z'
-};
-
-export const DEFAULT_CREATIVE_WORKFLOW: Workflow = {
-  id: 'wf_creative_default',
-  name: 'Creative Production Workflow',
-  description: 'Production pipeline for creative deliverables from briefing and concepts to internal review, client feedback, and final delivery.',
-  statuses: [
-    { key: 'briefing', label: 'Briefing & Scoping', category: 'not_started' },
-    { key: 'concept', label: 'Concept & Storyboarding', category: 'in_progress' },
-    { key: 'in_production', label: 'In Production', category: 'in_progress' },
-    { key: 'internal_review', label: 'Internal Review', category: 'in_progress' },
-    { key: 'client_review', label: 'Client Review', category: 'in_progress' },
-    { key: 'revision_requested', label: 'Revision Requested', category: 'in_progress' },
-    { key: 'approved', label: 'Approved', category: 'completed' },
-    { key: 'delivered', label: 'Delivered', category: 'completed' },
-    DEFAULT_STATUS_DEFINITIONS.canceled
-  ],
-  transitions: [
-    { name: 'Start Concepts', fromStatusKey: 'briefing', toStatusKey: 'concept' },
-    { name: 'Approve Concept for Production', fromStatusKey: 'concept', toStatusKey: 'in_production' },
-    { name: 'Return to Briefing', fromStatusKey: 'concept', toStatusKey: 'briefing' },
-    { name: 'Submit for Internal Review', fromStatusKey: 'in_production', toStatusKey: 'internal_review' },
-    { name: 'Submit for Client Review', fromStatusKey: 'in_production', toStatusKey: 'client_review' },
-    { name: 'Submit for Client Review', fromStatusKey: 'internal_review', toStatusKey: 'client_review' },
-    { name: 'Request Revisions (Internal)', fromStatusKey: 'internal_review', toStatusKey: 'revision_requested' },
-    { name: 'Return to Production', fromStatusKey: 'internal_review', toStatusKey: 'in_production' },
-    { name: 'Approve from Lead Review', fromStatusKey: 'internal_review', toStatusKey: 'approved' },
-    { name: 'Request Revisions (Client)', fromStatusKey: 'client_review', toStatusKey: 'revision_requested' },
-    { name: 'Return to Internal Review', fromStatusKey: 'client_review', toStatusKey: 'internal_review' },
-    { name: 'Address Revisions', fromStatusKey: 'revision_requested', toStatusKey: 'in_production' },
-    { name: 'Resubmit to Lead Review', fromStatusKey: 'revision_requested', toStatusKey: 'internal_review' },
-    { name: 'Resubmit to Client Review', fromStatusKey: 'revision_requested', toStatusKey: 'client_review' },
-    { name: 'Approve Work', fromStatusKey: 'client_review', toStatusKey: 'approved' },
-    { name: 'Deliver Final Assets', fromStatusKey: 'approved', toStatusKey: 'delivered' },
-    { name: 'Reopen Deliverable', fromStatusKey: 'delivered', toStatusKey: 'in_production' },
-    { name: 'Cancel', fromStatusKey: '*', toStatusKey: 'canceled' },
-    { name: 'Restore', fromStatusKey: 'canceled', toStatusKey: 'briefing' }
-  ],
-  taskTypes: [
-    { key: 'deliverable', label: 'Deliverable', description: 'Finished asset, cutdown, or packaged export', icon: 'package' },
-    { key: 'creative_task', label: 'Creative Task', description: 'Production task (e.g. Design, Copy, Editing, Color)', icon: 'pen-tool' },
-    { key: 'review', label: 'Review Gate', description: 'Internal or external client sign-off', icon: 'check-circle' }
-  ],
-  defaultStatusKey: 'briefing',
-  isDefault: false,
-  createdAt: '2026-01-01T00:00:00.000Z',
-  updatedAt: '2026-01-01T00:00:00.000Z'
-};
-
-export function validateTransition(
-  workflow: Workflow | undefined,
-  fromStatus: string,
-  toStatus: string
-): boolean {
-  if (fromStatus === toStatus) return true;
-  if (!workflow || !workflow.transitions || workflow.transitions.length === 0) return true;
-
-  return workflow.transitions.some(
-    (t) =>
-      (t.fromStatusKey === '*' || t.fromStatusKey === fromStatus) &&
-      (t.toStatusKey === '*' || t.toStatusKey === toStatus)
-  );
-}
-
-export function getAllowedNextStatuses(
-  workflow: Workflow | undefined,
-  currentStatus: string
-): string[] {
-  if (!workflow || !workflow.statuses || workflow.statuses.length === 0) {
-    return Object.keys(DEFAULT_STATUS_DEFINITIONS);
-  }
-
-  const allStatusKeys = workflow.statuses.map((s) => s.key);
-  const currentIndex = allStatusKeys.indexOf(currentStatus);
-  if (currentIndex === -1 || currentIndex >= allStatusKeys.length - 1) {
-    return [];
-  }
-
-  const nextStatusKeys = allStatusKeys.slice(currentIndex + 1);
-
-  if (workflow.transitions && workflow.transitions.length > 0) {
-    const matches = workflow.transitions.filter(
-      (t) => t.fromStatusKey === '*' || t.fromStatusKey === currentStatus
-    );
-
-    const allowed = new Set<string>();
-    for (const t of matches) {
-      if (t.toStatusKey === '*') {
-        return nextStatusKeys;
-      }
-      if (nextStatusKeys.includes(t.toStatusKey)) {
-        allowed.add(t.toStatusKey);
-      }
-    }
-
-    return Array.from(allowed);
-  }
-
-  return [allStatusKeys[currentIndex + 1]];
-}
-
-export function getAllowedTransitions(
-  workflow: Workflow | undefined,
-  currentStatus: string
-): string[] {
-  if (!workflow || !workflow.statuses || workflow.statuses.length === 0) {
-    return Object.keys(DEFAULT_STATUS_DEFINITIONS);
-  }
-
-  const allStatusKeys = workflow.statuses.map((s) => s.key);
-  if (!allStatusKeys.includes(currentStatus)) {
-    return [];
-  }
-
-  if (workflow.transitions && workflow.transitions.length > 0) {
-    const matches = workflow.transitions.filter(
-      (t) => t.fromStatusKey === '*' || t.fromStatusKey === currentStatus
-    );
-
-    const allowed = new Set<string>();
-    for (const t of matches) {
-      if (t.toStatusKey === '*') {
-        allStatusKeys.filter((k) => k !== currentStatus).forEach((k) => allowed.add(k));
-      } else if (t.toStatusKey !== currentStatus && allStatusKeys.includes(t.toStatusKey)) {
-        allowed.add(t.toStatusKey);
-      }
-    }
-
-    return Array.from(allowed);
-  }
-
-  const next = getAllowedNextStatuses(workflow, currentStatus);
-  const prev = getAllowedPreviousStatuses(workflow, currentStatus);
-  return Array.from(new Set([...next, ...prev]));
-}
-
-export function getAllowedPreviousStatuses(
-  workflow: Workflow | undefined,
-  currentStatus: string
-): string[] {
-  if (!workflow || !workflow.statuses || workflow.statuses.length === 0) {
-    return [];
-  }
-
-  const allStatusKeys = workflow.statuses.map((s) => s.key);
-  const currentIndex = allStatusKeys.indexOf(currentStatus);
-  if (currentIndex <= 0) {
-    return [];
-  }
-
-  const previousStatusKeys = allStatusKeys.slice(0, currentIndex);
-
-  if (workflow.transitions && workflow.transitions.length > 0) {
-    const matches = workflow.transitions.filter(
-      (t) => t.fromStatusKey === '*' || t.fromStatusKey === currentStatus
-    );
-
-    const allowed = new Set<string>();
-    for (const t of matches) {
-      if (t.toStatusKey === '*') {
-        return previousStatusKeys;
-      }
-      if (previousStatusKeys.includes(t.toStatusKey)) {
-        allowed.add(t.toStatusKey);
-      }
-    }
-
-    return Array.from(allowed);
-  }
-
-  return [allStatusKeys[currentIndex - 1]];
-}

package/src/webhooks/dispatcher.ts

@@ -1,190 +0,0 @@
-import type { Webhook } from '../types/index.js';
-import type { DomainEvent } from '../domain/events.js';
-import { signWebhookPayload } from './signature.js';
-
-/** One attempt to deliver one event to one webhook. Serializable, so durable queues can store it. */
-export interface WebhookDeliveryJob {
-  /** Stable per event and webhook (`<eventId>:<webhookId>`); sent as `X-CriticalPath-Delivery`. */
-  id: string;
-  webhookId: string;
-  url: string;
-  secret?: string;
-  event: string;
-  /** JSON body, signed as-is. */
-  body: string;
-  /** 1-based attempt number. */
-  attempt: number;
-}
-
-/**
- * Schedules delivery jobs. The default `InProcessWebhookQueue` keeps jobs in memory (lost on
- * restart). A durable queue persists `job` and, when `delayMs` has passed, calls
- * `engine.webhooks.deliver(job)` from a worker.
- */
-export interface WebhookDeliveryQueue {
-  enqueue(job: WebhookDeliveryJob, delayMs: number): void | Promise<void>;
-}
-
-export interface WebhookDeliveryOptions {
-  /** Custom queue (e.g. backed by a database or job runner). Default: in-process timers. */
-  queue?: WebhookDeliveryQueue;
-  /** Fetch implementation. Default: global `fetch`. */
-  fetch?: typeof fetch;
-  /** Per-attempt timeout. Default 10 000 ms. */
-  timeoutMs?: number;
-  /** Attempts before giving up. Default 5. */
-  maxAttempts?: number;
-  /** First retry delay; doubles each attempt. Default 1 000 ms. */
-  retryBaseDelayMs?: number;
-  /**
-   * Allow webhook URLs that point at localhost or private network addresses. Default `false`,
-   * which blocks literal private hosts to reduce SSRF risk (DNS-based tricks are not detected).
-   */
-  allowPrivateUrls?: boolean;
-  onDelivered?: (job: WebhookDeliveryJob, status: number) => void;
-  /** Called after the final failed attempt. Default: `console.warn`. */
-  onDeliveryFailed?: (job: WebhookDeliveryJob, error: unknown) => void;
-}
-
-export interface WebhookSource {
-  listWebhooks(): Promise<Webhook[]>;
-  /** The tenant an event belongs to; only webhooks with the same `tenantId` receive it. */
-  resolveTenant(event: DomainEvent): Promise<string | undefined>;
-}
-
-/** Default queue: runs jobs on timers in this process. Timers do not keep the process alive. */
-export class InProcessWebhookQueue implements WebhookDeliveryQueue {
-  private outstanding = 0;
-  private waiters: Array<() => void> = [];
-
-  constructor(private readonly run: (job: WebhookDeliveryJob) => Promise<void>) {}
-
-  enqueue(job: WebhookDeliveryJob, delayMs: number): void {
-    this.outstanding++;
-    const timer = setTimeout(async () => {
-      try {
-        await this.run(job);
-      } finally {
-        this.outstanding--;
-        if (this.outstanding === 0) this.waiters.splice(0).forEach((resolve) => resolve());
-      }
-    }, delayMs);
-    (timer as { unref?: () => void }).unref?.();
-  }
-
-  /** Resolves when no deliveries (including scheduled retries) are pending. */
-  idle(): Promise<void> {
-    return this.outstanding === 0 ? Promise.resolve() : new Promise((resolve) => this.waiters.push(resolve));
-  }
-}
-
-const PRIVATE_HOST = /^(localhost|.*\.localhost|.*\.internal|127\.\d+\.\d+\.\d+|10\.\d+\.\d+\.\d+|192\.168\.\d+\.\d+|172\.(1[6-9]|2\d|3[01])\.\d+\.\d+|169\.254\.\d+\.\d+|0\.0\.0\.0|\[::1?\]|\[f[cd][0-9a-f]*:.*\]|\[fe80:.*\])$/i;
-
-/** Throws if `url` is not an acceptable webhook target. */
-export function assertWebhookUrl(url: string, allowPrivateUrls = false): void {
-  let parsed: URL;
-  try {
-    parsed = new URL(url);
-  } catch {
-    throw new Error(`Invalid webhook URL "${url}".`);
-  }
-  if (parsed.protocol !== 'https:' && parsed.protocol !== 'http:') {
-    throw new Error('Webhook URLs must use http or https.');
-  }
-  if (!allowPrivateUrls && PRIVATE_HOST.test(parsed.hostname)) {
-    throw new Error(`Webhook URL host "${parsed.hostname}" is a private or local address. Set webhookDelivery.allowPrivateUrls to allow it.`);
-  }
-}
-
-/**
- * Turns domain events into signed webhook deliveries with timeouts and exponential-backoff retries.
- * Subscribed to the engine's event bus, so every published event is deliverable.
- */
-export class WebhookDispatcher {
-  private readonly queue: WebhookDeliveryQueue;
-  private readonly fetchImpl: typeof fetch;
-  private cache?: Promise<Webhook[]>;
-
-  constructor(
-    private readonly source: WebhookSource,
-    private readonly options: WebhookDeliveryOptions = {}
-  ) {
-    this.queue = options.queue ?? new InProcessWebhookQueue((job) => this.deliver(job));
-    this.fetchImpl = options.fetch ?? ((...args) => fetch(...args));
-  }
-
-  /** Drops cached webhooks; call after creating, updating or deleting one. */
-  invalidate(): void {
-    this.cache = undefined;
-  }
-
-  /** Resolves when the default in-process queue has nothing pending. */
-  idle(): Promise<void> {
-    return this.queue instanceof InProcessWebhookQueue ? this.queue.idle() : Promise.resolve();
-  }
-
-  async handle(event: DomainEvent): Promise<void> {
-    this.cache ??= this.source.listWebhooks().catch((err) => {
-      this.cache = undefined;
-      throw err;
-    });
-    const subscribed = (await this.cache).filter(
-      (w) => w.active && (w.events.includes('*') || w.events.includes(event.name as Webhook['events'][number]))
-    );
-    if (subscribed.length === 0) return;
-
-    const tenantId = await this.source.resolveTenant(event);
-    const targets = subscribed.filter((w) => w.tenantId === tenantId);
-    if (targets.length === 0) return;
-
-    const body = JSON.stringify({
-      id: event.id,
-      event: event.name,
-      occurredAt: event.occurredAt,
-      ...(tenantId ? { tenantId } : {}),
-      data: event.payload
-    });
-    for (const webhook of targets) {
-      await this.queue.enqueue(
-        { id: `${event.id}:${webhook.id}`, webhookId: webhook.id, url: webhook.url, secret: webhook.secret, event: event.name, body, attempt: 1 },
-        0
-      );
-    }
-  }
-
-  /** Makes one delivery attempt, scheduling a retry (or reporting failure) if it does not succeed. */
-  async deliver(job: WebhookDeliveryJob): Promise<void> {
-    const maxAttempts = this.options.maxAttempts ?? 5;
-    try {
-      assertWebhookUrl(job.url, this.options.allowPrivateUrls);
-      const timestamp = Math.floor(Date.now() / 1000);
-      const headers: Record<string, string> = {
-        'Content-Type': 'application/json',
-        'User-Agent': 'CriticalPath-Webhooks/1',
-        'X-CriticalPath-Event': job.event,
-        'X-CriticalPath-Delivery': job.id,
-        'X-CriticalPath-Timestamp': String(timestamp)
-      };
-      if (job.secret) {
-        headers['X-CriticalPath-Signature'] = await signWebhookPayload({ secret: job.secret, body: job.body, timestamp });
-      }
-      const response = await this.fetchImpl(job.url, {
-        method: 'POST',
-        headers,
-        body: job.body,
-        signal: AbortSignal.timeout(this.options.timeoutMs ?? 10_000)
-      });
-      if (!response.ok) throw new Error(`Webhook responded with HTTP ${response.status}`);
-      this.options.onDelivered?.(job, response.status);
-    } catch (error) {
-      if (job.attempt < maxAttempts) {
-        const delay = (this.options.retryBaseDelayMs ?? 1_000) * 2 ** (job.attempt - 1);
-        await this.queue.enqueue({ ...job, attempt: job.attempt + 1 }, delay);
-      } else if (this.options.onDeliveryFailed) {
-        this.options.onDeliveryFailed(job, error);
-      } else {
-        console.warn(`[CriticalPath Webhooks] Giving up on delivery ${job.id} to ${job.url} after ${job.attempt} attempts:`, error);
-      }
-    }
-  }
-}

package/src/webhooks/index.ts

@@ -1,2 +0,0 @@
-export * from './signature.js';
-export * from './dispatcher.js';

package/src/webhooks/signature.ts

@@ -1,57 +0,0 @@
-/**
- * Webhook signing (HMAC-SHA256 over `"<timestamp>.<body>"`) using Web Crypto, so it works in
- * Node, edge runtimes and browsers alike.
- */
-
-const encoder = new TextEncoder();
-
-async function hmacHex(secret: string, message: string): Promise<string> {
-  const key = await crypto.subtle.importKey('raw', encoder.encode(secret), { name: 'HMAC', hash: 'SHA-256' }, false, [
-    'sign'
-  ]);
-  const signature = await crypto.subtle.sign('HMAC', key, encoder.encode(message));
-  return Array.from(new Uint8Array(signature), (b) => b.toString(16).padStart(2, '0')).join('');
-}
-
-function constantTimeEqual(a: string, b: string): boolean {
-  if (a.length !== b.length) return false;
-  let diff = 0;
-  for (let i = 0; i < a.length; i++) diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
-  return diff === 0;
-}
-
-/** Returns the `X-CriticalPath-Signature` header value: `sha256=<hex>`. */
-export async function signWebhookPayload(input: { secret: string; body: string; timestamp: number }): Promise<string> {
-  return `sha256=${await hmacHex(input.secret, `${input.timestamp}.${input.body}`)}`;
-}
-
-export interface VerifyWebhookSignatureInput {
-  secret: string;
-  /** The raw request body, exactly as received. */
-  body: string;
-  /** `X-CriticalPath-Timestamp` header (Unix seconds). */
-  timestamp: string | number;
-  /** `X-CriticalPath-Signature` header. */
-  signature: string;
-  /** Reject deliveries older or newer than this many seconds (replay protection). Default 300. */
-  toleranceSeconds?: number;
-  /** Current time in milliseconds, for tests. */
-  now?: number;
-}
-
-/** Verifies a delivery in a webhook receiver. */
-export async function verifyWebhookSignature(input: VerifyWebhookSignatureInput): Promise<boolean> {
-  const timestamp = Number(input.timestamp);
-  if (!Number.isFinite(timestamp)) return false;
-  const tolerance = input.toleranceSeconds ?? 300;
-  const nowSeconds = Math.floor((input.now ?? Date.now()) / 1000);
-  if (Math.abs(nowSeconds - timestamp) > tolerance) return false;
-  const expected = await signWebhookPayload({ secret: input.secret, body: input.body, timestamp });
-  return constantTimeEqual(expected, input.signature);
-}
-
-/** Generates a random signing secret (`whsec_` + 64 hex characters). */
-export function generateWebhookSecret(): string {
-  const bytes = crypto.getRandomValues(new Uint8Array(32));
-  return `whsec_${Array.from(bytes, (b) => b.toString(16).padStart(2, '0')).join('')}`;
-}