@funnelchat-hq/sandbox 0.0.0-stage → 0.1.0

package/dist/cli.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+import { ConfigError, parseArgs, VERSION, DEFAULT_PORT, DEFAULT_CONFIG_FILE, resolveConfig, createSandbox } from './chunk-PF4CGK6J.js';
+
+// src/cli.ts
+var HELP = `funnelchat-sandbox ${VERSION}
+Imitates the Funnelchat public API on your machine and sends signed webhooks. Nothing goes out to WhatsApp.
+
+Usage: npx funnelchat-sandbox [options]
+
+Options:
+  -p, --port <n>                 Port (default ${DEFAULT_PORT}; 0 takes a free one).
+      --host <host>              Where to listen (default 127.0.0.1; in Docker, 0.0.0.0).
+  -c, --config <file>            JSON configuration (default ./${DEFAULT_CONFIG_FILE}, if it exists).
+      --status-delays <s,d,r>    Seconds until sent, delivered and read (default 1,2,3; "-" stops there).
+      --retry-delays <a,b,c>     Seconds between retries of a webhook (default 60,300,1800).
+      --webhook-timeout <s>      How long your receiver may take (default 10).
+      --require-https            Only accept https subscriptions, like the real API.
+      --no-window                Do not apply the 24-hour window.
+      --no-antiblock             Do not apply the spam brakes.
+      --no-rate-limit            Do not apply the per-number pace.
+      --template-approval <s>    Seconds until a new template is approved (default 5; "-" leaves it pending).
+  -q, --quiet                    No line per request and per delivery.
+  -h, --help                     This help.
+  -v, --version                  The version.
+
+Options win over the configuration file. Panel: http://localhost:${DEFAULT_PORT}/_sandbox`;
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    console.log(HELP);
+    return;
+  }
+  if (args.version) {
+    console.log(VERSION);
+    return;
+  }
+  const { config, configFile } = resolveConfig(args);
+  const sandbox = createSandbox({ config });
+  const { url } = await sandbox.listen();
+  console.log(`funnelchat-sandbox ${VERSION} at ${url}`);
+  if (configFile) console.log(`configuration: ${configFile}`);
+  console.log(`  API:    ${url}/api/v1/...   (Authorization: Bearer 1|fc_live_sandbox, or any well-formed key)`);
+  console.log(`  panel:  ${url}/_sandbox`);
+  console.log("  example numbers: 3 (official, with the 24-hour window) and 4 (QR, no window); contact 2001; template 45");
+  for (const s of sandbox.app.store.subscriptions.values()) {
+    console.log(`  subscription from the configuration: ${s.id} \u2192 ${s.url} (${s.events.join(", ")})`);
+  }
+  let closing = false;
+  const stop = (signal) => {
+    if (closing) return;
+    closing = true;
+    console.log(`
+${signal}: closing the sandbox`);
+    void sandbox.close().then(() => process.exit(0));
+  };
+  process.on("SIGINT", () => stop("SIGINT"));
+  process.on("SIGTERM", () => stop("SIGTERM"));
+}
+main().catch((error) => {
+  if (error instanceof ConfigError) {
+    console.error(`funnelchat-sandbox: ${error.message}`);
+    process.exit(2);
+  }
+  const code = error.code;
+  if (code === "EADDRINUSE") {
+    console.error("funnelchat-sandbox: the port is in use. Try --port <another>.");
+    process.exit(1);
+  }
+  console.error(error);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map
+//# sourceMappingURL=cli.js.map

package/dist/index.d.ts

@@ -0,0 +1,490 @@
+import { Server } from 'node:http';
+
+/** A subscription created when the sandbox starts (and after every reset), with a fixed secret. */
+interface PresetSubscription {
+    url: string;
+    events: string[];
+    description?: string | null;
+    /** Optional: a fixed secret, so your receiver keeps working across restarts. One is generated otherwise. */
+    secret?: string;
+    /** Optional: a fixed id (UUID). */
+    id?: string;
+}
+interface SandboxConfig {
+    port: number;
+    host: string;
+    /** Seconds from one state to the next of an accepted message: queued → sent → delivered → read. `null` stops there. */
+    statusDelays: {
+        sent: number;
+        delivered: number | null;
+        read: number | null;
+    };
+    webhooks: {
+        /** Seconds to wait before attempts 2, 3 and 4 (the portal: 60, 300, 1800). */
+        retryDelays: number[];
+        /** A delivery counts as failed if the receiver takes longer (the portal: 10 s). */
+        timeoutSeconds: number;
+        /** Consecutive failed deliveries that disable a subscription (accounts: 5). */
+        maxConsecutiveFailures: number;
+        /** The real API only accepts public `https` URLs. The sandbox accepts `http` and local addresses unless this is `true`. */
+        requireHttps: boolean;
+    };
+    rules: {
+        /** The 24-hour window on official (Cloud) numbers: `422 window_closed`. */
+        window: boolean;
+        /** The spam brakes: `422 antiblock_duplicate_content` and `422 antiblock_unanswered_limit`. */
+        antiblock: boolean;
+        /** The pace of official numbers: `429 rate_limited` with `Retry-After`. */
+        rateLimit: boolean;
+    };
+    /** Seconds until a template created through the API goes from `PENDING` to `APPROVED`. `null`: it stays pending. */
+    templateApprovalSeconds: number | null;
+    /** Subscriptions to create at start and after every reset. */
+    subscriptions: PresetSubscription[];
+    /** How many requests and deliveries the panel keeps. */
+    historyLimit: number;
+    /** One line per request and per delivery on the console. */
+    log: boolean;
+}
+declare function defaultConfig(): SandboxConfig;
+type ConfigInput = {
+    [K in keyof SandboxConfig]?: SandboxConfig[K] extends Record<string, unknown> ? Partial<SandboxConfig[K]> : SandboxConfig[K];
+};
+/** Merges a partial configuration over a full one, checking every value. */
+declare function mergeConfig(base: SandboxConfig, input: ConfigInput): SandboxConfig;
+
+type PublicStatus = 'queued' | 'sent' | 'delivered' | 'read' | 'failed';
+interface MessageError {
+    code: number | null;
+    title: string | null;
+    reason: string | null;
+}
+type DeviceKind = 'cloud' | 'qr';
+interface Device {
+    id: number;
+    alias: string;
+    /** Digits only, without `+`. */
+    number: string;
+    /** WhatsAppProviderEnum of accounts: 1 Z-API (QR), 2 WhatsApp Cloud (official). */
+    provider: 1 | 2;
+    kind: DeviceKind;
+    connected: boolean;
+    wabaId: string | null;
+    phoneNumberId: string | null;
+    createdAt: Date;
+}
+interface Contact {
+    id: number;
+    name: string | null;
+    email: string | null;
+    /** Digits only: the API stores the phone without `+`. */
+    phone: string | null;
+    whatsappId: string | null;
+    image: string | null;
+    notes: string | null;
+    status: number;
+    activeConversation: boolean;
+    favorite: boolean;
+    unreadMessages: number;
+    manuallyUnread: boolean;
+    deviceId: number | null;
+    adviserId: number | null;
+    pausedAt: Date | null;
+    tags: Map<number, Date>;
+    customFields: Map<number, {
+        value: string;
+        createdAt: Date;
+        updatedAt: Date;
+    }>;
+    createdAt: Date;
+    updatedAt: Date;
+}
+interface Message {
+    id: number;
+    contactId: number;
+    deviceId: number | null;
+    own: boolean;
+    /** Public type name (`text`, `image`, `template`, `contact`, `note`…). */
+    type: string;
+    text: string | null;
+    file: string | null;
+    status: PublicStatus | null;
+    error: MessageError | null;
+    clientReference: string | null;
+    uid: string;
+    /** Sent with an API key: it has the queued → sent → delivered → read lifecycle and emits its states. */
+    viaApi: boolean;
+    templateId: number | null;
+    reactions: {
+        emoji: string;
+        own: boolean;
+    }[];
+    createdAt: Date;
+    updatedAt: Date;
+}
+interface Tag {
+    id: number;
+    name: string;
+    color: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+}
+interface CustomField {
+    id: number;
+    name: string;
+    type: number;
+    createdAt: Date;
+    updatedAt: Date;
+}
+type TemplateStatus = 'PENDING' | 'APPROVED' | 'REJECTED' | 'PAUSED' | 'DISABLED';
+interface Template {
+    id: number;
+    uid: string;
+    name: string;
+    body: string;
+    header: string | null;
+    footer: string | null;
+    category: string;
+    type: string;
+    status: TemplateStatus;
+    languageCode: string;
+    deviceId: number;
+    file: string | null;
+    params: string[] | null;
+    buttons: {
+        text?: string;
+        type?: string;
+        url?: string;
+        phone_number?: string;
+    }[] | null;
+    rejectionReason: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+}
+type SubscriptionStatus = 'active' | 'paused' | 'disabled';
+interface Subscription {
+    id: string;
+    url: string;
+    description: string | null;
+    events: string[];
+    filters: {
+        campaign_ids?: string[];
+    };
+    status: SubscriptionStatus;
+    disabledReason: 'too_many_failures' | 'key_revoked' | null;
+    consecutiveFailures: number;
+    secret: string;
+    lastDeliveryAt: Date | null;
+    lastSuccessAt: Date | null;
+    secretRotatedAt: Date | null;
+    createdAt: Date;
+    updatedAt: Date;
+}
+interface Delivery {
+    id: number;
+    subscriptionId: string;
+    eventId: string;
+    eventType: string;
+    attempt: number;
+    url: string;
+    responseStatus: number | null;
+    succeeded: boolean;
+    error: string | null;
+    durationMs: number | null;
+    attemptedAt: Date;
+    /** Sandbox only (the panel): the start of what the receiver answered, and the delivered body. */
+    responseBody: string | null;
+    requestBody: string;
+    /** Sandbox only: when the next attempt is due, if there is one. */
+    nextAttemptAt: Date | null;
+}
+/** One version of a WhatsApp form (conversations `whatsapp_forms`); its family is the stable form. */
+interface FormVersion {
+    id: number;
+    familyId: number;
+    /** Unique per number; a new version is `<label>__v<n>`. */
+    name: string;
+    category: string;
+    status: 'draft' | 'published';
+    version: number;
+    definition: Record<string, unknown>;
+    /** The number it was created with (`primary`). */
+    deviceId: number;
+    /** The other numbers (`whatsapp_form_copies`). */
+    copies: Map<number, {
+        status: 'draft' | 'publishing' | 'published' | 'failed';
+        error: string | null;
+    }>;
+    metaFlowId: string | null;
+    publishedAt: Date | null;
+    createdAt: Date;
+    updatedAt: Date;
+}
+interface FormFamily {
+    id: number;
+    /** The published version a send uses. */
+    currentVersionId: number | null;
+}
+/** One send of a form to a contact, and its answers (conversations `whatsapp_form_runs`). */
+interface FormRun {
+    id: number;
+    familyId: number;
+    versionId: number;
+    contactId: number;
+    deviceId: number;
+    messageId: number;
+    status: 'pending' | 'completed';
+    answers: Record<string, unknown> | null;
+    sentAt: Date;
+    respondedAt: Date | null;
+}
+interface RequestLogEntry {
+    id: number;
+    at: Date;
+    /** The `X-Request-Id` of the answer. */
+    requestId: string;
+    method: string;
+    path: string;
+    status: number;
+    durationMs: number;
+    operation: string | null;
+    requestBody: unknown;
+    responseBody: unknown;
+}
+/** A failure armed with `POST /_sandbox/failures` or the `X-Sandbox-*` headers. */
+interface ArmedFailure {
+    id: number;
+    /**
+     * `reject`: the send answers an error right away. `fail`: it is accepted and then ends `failed`. `edge`: the next
+     * API call (any route) gets an error of the edge.
+     */
+    mode: 'reject' | 'fail' | 'edge';
+    code: string;
+    remaining: number;
+    contactId: number | null;
+    /** `edge` only: the call reached the domain and was applied; only the answer was lost. */
+    applied?: boolean;
+}
+declare class Sequence {
+    #private;
+    readonly start: number;
+    constructor(start: number);
+    next(): number;
+    bump(atLeast: number): void;
+}
+declare class Store {
+    readonly historyLimit: number;
+    devices: Map<number, Device>;
+    contacts: Map<number, Contact>;
+    messages: Map<number, Message>;
+    tags: Map<number, Tag>;
+    customFields: Map<number, CustomField>;
+    templates: Map<number, Template>;
+    subscriptions: Map<string, Subscription>;
+    deliveries: Delivery[];
+    requests: RequestLogEntry[];
+    failures: ArmedFailure[];
+    forms: Map<number, FormVersion>;
+    formFamilies: Map<number, FormFamily>;
+    formRuns: Map<number, FormRun>;
+    /** Last inbound message per `contactId:deviceId`: the 24-hour window. */
+    lastInbound: Map<string, Date>;
+    /** API-key sends per contact since its last inbound message: the antiblock counters. */
+    unanswered: Map<number, {
+        at: Date;
+        hash: string;
+    }[]>;
+    /** Recent API-key sends per number and per `deviceId:contactId`: the pace. */
+    pace: Map<string, number[]>;
+    /** The MAC state of the account (`POST /_sandbox/mac`): the 24-hour lockout, and contacts active or inactive in the cycle. */
+    mac: {
+        lockout: boolean;
+        activeContacts: Set<number>;
+        inactiveContacts: Set<number>;
+    };
+    /** Salt of the deterministic event ids: new on every reset, so ids never repeat across sessions. */
+    eventSalt: string;
+    readonly ids: {
+        contact: Sequence;
+        message: Sequence;
+        tag: Sequence;
+        customField: Sequence;
+        template: Sequence;
+        delivery: Sequence;
+        request: Sequence;
+        failure: Sequence;
+        note: Sequence;
+        formFamily: Sequence;
+        formVersion: Sequence;
+        formRun: Sequence;
+    };
+    constructor(historyLimit?: number);
+    logRequest(entry: Omit<RequestLogEntry, 'id'>): RequestLogEntry;
+    addDelivery(entry: Omit<Delivery, 'id'>): Delivery;
+    findContactByPhone(phone: string): Contact | undefined;
+    contactMessages(contactId: number): Message[];
+    windowOpen(contactId: number, deviceId: number, now?: Date): boolean;
+}
+
+/**
+ * Emission and delivery of events to the webhook subscriptions, like accounts' unified subscriptions
+ * (`WebhookEventDispatcher`, `DeliverSubscriptionEventJob`, `SubscriptionWebhookSender`, platform-gate
+ * `RetryPolicy`):
+ *
+ * - one envelope `{id, type, version, occurred_at, data}` per event, serialized once: every subscription and every
+ *   retry gets the same bytes and the same `id`;
+ * - one signed `POST` per subscription, with `X-Funnelchat-Signature` (a fresh `t` per attempt),
+ *   `X-Funnelchat-Event` and `X-Funnelchat-Delivery` (a new UUID per attempt), no redirects, a 10 s timeout;
+ * - up to 4 attempts, waiting 60 s, 300 s and 1800 s (configurable); a network error, a timeout, a `5xx` or a
+ *   `429` is retried, any other answer that is not `2xx` is final;
+ * - a delivery that runs out of attempts counts one consecutive failure; at 5 the subscription is disabled
+ *   (`too_many_failures`); a success resets the count;
+ * - each attempt checks again that the subscription exists, is `active` and still wants the type.
+ */
+
+interface EmitOptions {
+    id?: string;
+    occurredAt?: Date;
+}
+interface Envelope$1 {
+    id: string;
+    type: string;
+    version: number;
+    occurred_at: string;
+    data: unknown;
+}
+interface SendResult {
+    status: number | null;
+    error: string | null;
+    durationMs: number;
+    body: string | null;
+}
+declare class Webhooks {
+    private readonly app;
+    constructor(app: SandboxApp);
+    get maxAttempts(): number;
+    /** Builds the envelope, exactly as it is delivered. */
+    envelope(type: string, data: unknown, options?: EmitOptions): Envelope$1;
+    /** Emits one event to every active subscription that wants it. Returns the envelope and how many got it. */
+    emit(type: string, data: unknown, options?: EmitOptions): {
+        envelope: Envelope$1;
+        subscriptions: number;
+    };
+    /** One signed POST. Never throws: the result says what happened. */
+    send(subscription: Subscription, type: string, body: string): Promise<SendResult>;
+    private shouldRetry;
+    private attempt;
+    /** `POST /api/v1/webhooks/{id}/test`: one synchronous `webhook.test`, no retries, no counters touched. */
+    test(subscription: Subscription): Promise<Record<string, unknown>>;
+}
+
+interface Logger {
+    info(message: string): void;
+    warn(message: string): void;
+}
+/** Timers of the sandbox (message states, retries, template approvals): all cleared on reset and on close. */
+declare class Scheduler {
+    #private;
+    after(ms: number, task: () => unknown): void;
+    get pending(): number;
+    clearAll(): void;
+}
+/** Everything a request handler needs: configuration, state, webhooks and timers. */
+declare class SandboxApp {
+    readonly config: SandboxConfig;
+    readonly logger: Logger;
+    store: Store;
+    readonly scheduler: Scheduler;
+    readonly webhooks: Webhooks;
+    /** Grows on every reset, so work started before a reset does not touch the new state. */
+    generation: number;
+    constructor(config: SandboxConfig, logger?: Logger);
+    private populate;
+    /** `POST /_sandbox/reset`: empty state, the example data again, timers cancelled. */
+    reset(): void;
+    close(): void;
+}
+
+/**
+ * `X-Request-Id`: a fresh UUID v4 on every answer, errors included, like api-edge v0.3.0 and platform-gate 0.8. Only
+ * in the header, never in the body; one the client sends is ignored.
+ */
+declare const REQUEST_ID_HEADER = "X-Request-Id";
+interface Sandbox {
+    app: SandboxApp;
+    server: Server;
+    /** Starts listening; resolves with the URL. Port `0` takes a free one. */
+    listen(): Promise<{
+        url: string;
+        port: number;
+    }>;
+    close(): Promise<void>;
+}
+interface CreateSandboxOptions {
+    config?: ConfigInput | SandboxConfig;
+    logger?: Logger;
+}
+declare function createSandbox(options?: CreateSandboxOptions): Sandbox;
+
+declare const SIGNATURE_HEADER = "X-Funnelchat-Signature";
+declare const EVENT_HEADER = "X-Funnelchat-Event";
+declare const DELIVERY_HEADER = "X-Funnelchat-Delivery";
+declare function signature(secret: string, body: string | Uint8Array, timestamp: number): string;
+
+interface Envelope {
+    id: string;
+    type: string;
+    version: number;
+    occurred_at: string;
+    data: unknown;
+}
+interface CatalogEntry {
+    type: string;
+    area: string;
+    /** `active`: accounts accepts and delivers it. `planned`: you can subscribe, but nothing is emitted yet. */
+    status: 'active' | 'planned';
+    is_critical: boolean;
+    label: string;
+    description: string;
+    subscribable: boolean;
+    example: Envelope | null;
+}
+declare const catalog: CatalogEntry[];
+
+/** The edge's own errors (api-edge v0.3.0 `src/index.ts`): `{error, message}`, no `Retry-After`. */
+declare const EDGE_ERRORS: Record<string, {
+    status: number;
+    message: string;
+}>;
+
+/** Errors of a rejected send: code → HTTP status and the message of conversations' `lang/es/public_api.php`. */
+declare const REJECTIONS: Record<string, {
+    status: number;
+    message: string;
+}>;
+/** `error.reason` of a message Funnelchat accepted and then stopped, with its title (`public_api.send_failure`, es). */
+declare const FAILURE_REASONS: Record<string, string>;
+/** Frequent error codes of the WhatsApp Cloud API, with the `title` Meta sends. */
+declare const META_ERRORS: Record<number, string>;
+
+declare const SEND_FILE_TYPES: readonly ["image", "video", "audio", "document", "sticker"];
+type SendFileType = (typeof SEND_FILE_TYPES)[number];
+/** `SupportedFileExtensionEnum`, mapped to the type of `messageTypeByFileExtension`. */
+declare const SUPPORTED_EXTENSIONS: Record<string, SendFileType>;
+
+/**
+ * The five starting points of `POST /api/v1/forms` (`template_key`), copied from conversations v1.18.10
+ * `database/seeders/WhatsappFormTemplatesSeeder.php`, in their `sort` order.
+ */
+interface FormTemplate {
+    key: string;
+    title: string;
+    description: string;
+    category: string;
+    definition: Record<string, unknown>;
+}
+declare const FORM_TEMPLATES: FormTemplate[];
+
+declare const VERSION: string;
+
+export { type CatalogEntry, type ConfigInput, type CreateSandboxOptions, DELIVERY_HEADER, EDGE_ERRORS, EVENT_HEADER, FAILURE_REASONS, FORM_TEMPLATES, META_ERRORS, type PresetSubscription, REJECTIONS, REQUEST_ID_HEADER, SEND_FILE_TYPES, SIGNATURE_HEADER, SUPPORTED_EXTENSIONS, type Sandbox, type SandboxConfig, VERSION, catalog, createSandbox, defaultConfig, mergeConfig, signature };

package/dist/index.js

@@ -0,0 +1,3 @@
+export { DELIVERY_HEADER, EDGE_ERRORS, EVENT_HEADER, FAILURE_REASONS, FORM_TEMPLATES, META_ERRORS, REJECTIONS, REQUEST_ID_HEADER, SEND_FILE_TYPES, SIGNATURE_HEADER, SUPPORTED_EXTENSIONS, VERSION, catalog, createSandbox, defaultConfig, mergeConfig, signature } from './chunk-PF4CGK6J.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/funnelchat-sandbox.config.example.json

@@ -0,0 +1,15 @@
+{
+  "port": 4010,
+  "statusDelays": { "sent": 1, "delivered": 2, "read": 3 },
+  "webhooks": { "retryDelays": [5, 15, 30], "timeoutSeconds": 10 },
+  "rules": { "window": true, "antiblock": true, "rateLimit": true },
+  "templateApprovalSeconds": 5,
+  "subscriptions": [
+    {
+      "url": "http://localhost:3000/hooks/funnelchat",
+      "events": ["message.received", "message.status_changed", "contact.created"],
+      "description": "My local receiver",
+      "secret": "whsec_desarrolloLocalNoUsarEnProduccion"
+    }
+  ]
+}

package/package.json

@@ -1,6 +1,79 @@
 {
   "name": "@funnelchat-hq/sandbox",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "A local server that imitates the Funnelchat public API and sends signed webhooks, with no real effects",
+  "license": "MIT",
+  "author": {
+    "name": "Funnelchat",
+    "email": "soporte@funnelchat.com"
+  },
+  "homepage": "https://developers-portal.funnelchat.app/docs/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Funnelchat20/funnelchat-sandbox.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Funnelchat20/funnelchat-sandbox/issues",
+    "email": "soporte@funnelchat.com"
+  },
+  "keywords": [
+    "funnelchat",
+    "whatsapp",
+    "api",
+    "sandbox",
+    "mock",
+    "webhooks"
+  ],
+  "type": "module",
+  "engines": {
+    "node": ">=20.11"
+  },
+  "bin": {
+    "funnelchat-sandbox": "dist/cli.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "spec/procedencia.json",
+    "funnelchat-sandbox.config.example.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "generate": "node scripts/generate.mjs",
+    "generate:check": "node scripts/generate.mjs --check",
+    "build": "tsup",
+    "start": "node dist/cli.js",
+    "dev": "tsup --watch --onSuccess \"node dist/cli.js\"",
+    "lint": "eslint .",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepack": "npm run build"
+  },
+  "dependencies": {
+    "ajv": "^8.17.1",
+    "ajv-formats": "^3.0.1"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.5",
+    "@types/node": "^20.19.43",
+    "eslint": "^9.39.5",
+    "tsup": "^8.5.1",
+    "typescript": "~5.9.3",
+    "typescript-eslint": "^8.71.2",
+    "vitest": "^4.1.12"
+  }
+}