@dinnger/wallet 0.0.0-stage → 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dinnger
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,145 @@
-# Temporary Holding Version
+# @dinnger/wallet
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Cliente de Node.js para emitir tarjetas de lealtad en **Google Wallet** a tus clientes: crea la tarjeta, suma y canjea
+puntos, registra ventas de caja, envía notificaciones y verifica webhooks. Con tipos de TypeScript y sin dependencias.
+
+```sh
+npm install @dinnger/wallet
+```
+
+Requiere Node.js 20.19 o superior. Es un paquete ESM; en proyectos CommonJS también funciona con `require`.
+
+## Primeros pasos
+
+```ts
+import { Wallet } from '@dinnger/wallet'
+
+const wallet = new Wallet({
+  apiKey: process.env.WALLET_API_KEY!, // sk_test_… o sk_live_…, del portal › Desarrolladores › API keys
+  baseUrl: 'https://wallet.example.com',
+})
+
+// 1. Crea (o actualiza) la tarjeta del cliente con TU identificador
+const member = await wallet.members.upsert('CLI-001', { name: 'Ana López', email: 'ana@example.com' })
+console.log(member.wallets.google?.saveUrl) // link «Agregar a Google Wallet»
+console.log(member.shortUrl) //               link corto para SMS o WhatsApp
+console.log(member.qrUrl) //                  PNG con el QR para mostrar en caja
+
+// 2. Suma puntos por una compra (idempotente: un reintento no duplica)
+await wallet.members.addPoints('CLI-001', { delta: 50, reason: 'Compra #1234', idempotencyKey: 'venta-1234' })
+
+// 3. Canjea
+await wallet.members.addPoints('CLI-001', { delta: -20, reason: 'Canje café' })
+```
+
+Con una llave `sk_test_…` las tarjetas salen marcadas como «PRUEBA»; nada de lo que hagas en modo prueba toca a tus
+clientes reales.
+
+## Cajas registradoras
+
+Los puntos los calcula la plataforma con las reglas configuradas en el portal (*Clientes › Cajas*). El QR de la tarjeta
+contiene el `customerId`. Una llave de caja solo puede usar `wallet.pos`.
+
+```ts
+// Cliente escaneado: saldo y valor de sus puntos
+const customer = await wallet.pos.customer('CLI-001')
+
+// Antes de cobrar: descuento por los puntos a canjear y puntos que dará la compra (no guarda nada)
+const quote = await wallet.pos.quote({ customerId: 'CLI-001', amountInCents: 25550, redeemPoints: 100 })
+
+// Al cobrar: canjea y suma en una sola operación. El número de ticket evita duplicados.
+const { sale } = await wallet.pos.createSale({
+  customerId: 'CLI-001',
+  receiptNumber: 'F-000123',
+  amountInCents: 25550, // Q255.50
+  redeemPoints: 100,
+})
+
+// Devolución total del ticket: quita los puntos ganados y regresa los canjeados
+await wallet.pos.refund('F-000123')
+```
+
+## Notificaciones push
+
+```ts
+// A un cliente («tu canje está listo»)
+await wallet.messages.sendToMember('CLI-001', { header: '¡Tu café gratis te espera!', body: 'Válido hasta el domingo.' })
+
+// Campaña a todos los clientes del programa
+await wallet.messages.broadcast({ header: 'Doble puntos', body: 'Este sábado en todas las tiendas.', expiresAt: '2026-10-12T05:59:59Z' })
+```
+
+El aviso en la pantalla de bloqueo lo pone Google y es genérico; tu `header` y tu `body` se ven al abrir la tarjeta.
+Google Wallet permite **3 notificaciones por tarjeta cada 24 h** (las campañas cuentan para todas); por encima, la API
+responde `429 notification_limit`.
+
+## Webhooks
+
+La firma se calcula sobre los bytes exactos que enviamos: usa el cuerpo **crudo**, sin volver a serializarlo.
+
+```ts
+import express from 'express'
+import { verifyWebhook } from '@dinnger/wallet'
+
+const app = express()
+
+app.post('/hooks/wallet', express.raw({ type: 'application/json' }), (req, res) => {
+  let event
+  try {
+    event = verifyWebhook(req.body, req.header('Wallet-Signature'), process.env.WALLET_WEBHOOK_SECRET!)
+  } catch {
+    return res.sendStatus(400) // firma inválida o fuera de la ventana de 5 minutos
+  }
+  if (event.type === 'member.saved') {
+    // el cliente guardó su tarjeta
+  }
+  res.sendStatus(200)
+})
+```
+
+Un evento puede llegar más de una vez: usa su `id` para no procesarlo dos veces.
+
+## Errores
+
+Toda respuesta que no es 2xx lanza `WalletError` con `status`, `code` y el `body` de la respuesta. Los errores de red,
+los 5xx y los 429 se reintentan solos (2 veces por defecto, con espera creciente; cámbialo con `retries`).
+
+```ts
+import { WalletError } from '@dinnger/wallet'
+
+try {
+  await wallet.members.addPoints('CLI-001', { delta: -500, reason: 'Canje TV' })
+} catch (err) {
+  if (err instanceof WalletError && err.code === 'insufficient_points') {
+    // muestra «saldo insuficiente» en la caja
+  } else {
+    throw err
+  }
+}
+```
+
+Códigos frecuentes: `insufficient_points`, `member_not_found`, `idempotency_conflict`, `demo_limit_reached`,
+`notification_limit`.
+
+## Referencia
+
+| Grupo | Métodos |
+|---|---|
+| `wallet` | `me()` |
+| `wallet.members` | `upsert`, `get`, `list`, `deactivate`, `addPoints`, `transactions` |
+| `wallet.pos` | `customer`, `quote`, `createSale`, `getSale`, `refund` |
+| `wallet.messages` | `sendToMember`, `broadcast`, `list` |
+| Funciones | `verifyWebhook(cuerpo, firma, secreto, toleranciaEnSegundos = 300)` |
+
+Opciones de `new Wallet({ … })`:
+
+| Opción | Tipo | Descripción |
+|---|---|---|
+| `apiKey` | `string` | Llave `sk_test_…` o `sk_live_…`. |
+| `baseUrl` | `string` | URL base de la API, p. ej. `https://wallet.example.com`. |
+| `retries` | `number` | Reintentos ante errores de red, 5xx o 429. Por defecto, 2. |
+| `fetch` | `typeof fetch` | Implementación de `fetch` propia (para pruebas o proxies). |
+
+## Licencia
+
+MIT. Ver [LICENSE](./LICENSE).

package/dist/index.d.ts

@@ -0,0 +1,232 @@
+export interface Member {
+    id: string;
+    customerId: string;
+    name: string;
+    email: string | null;
+    points: number;
+    tier: string | null;
+    state: 'ACTIVE' | 'INACTIVE';
+    mode: 'test' | 'live';
+    source: 'api' | 'join';
+    savedInWallet: boolean;
+    shortUrl: string;
+    qrUrl: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface MemberDetail extends Member {
+    wallets: {
+        google?: {
+            saveUrl: string;
+        };
+        apple?: {
+            saveUrl: string;
+        };
+    };
+}
+export interface PointTransaction {
+    id: number;
+    memberId: string;
+    delta: number;
+    balanceAfter: number;
+    reason: string | null;
+    idempotencyKey: string | null;
+    createdAt: string;
+}
+export interface Notification {
+    id: string;
+    scope: 'member' | 'program';
+    mode: 'test' | 'live';
+    header: string;
+    body: string;
+    expiresAt: string | null;
+    status: 'QUEUED' | 'SENT' | 'FAILED';
+    error: string | null;
+    sentAt: string | null;
+    createdAt: string;
+}
+export interface MessageInput {
+    header: string;
+    body: string;
+    /** ISO 8601; hasta cuándo se muestra el mensaje en la tarjeta. */
+    expiresAt?: string;
+}
+export interface PosSale {
+    id: string;
+    mode: 'test' | 'live';
+    receiptNumber: string;
+    /** Total del ticket antes del descuento por puntos. */
+    amountInCents: number;
+    discountInCents: number;
+    /** Lo que pagó el cliente. */
+    totalInCents: number;
+    currency: 'GTQ' | 'USD';
+    pointsEarned: number;
+    pointsRedeemed: number;
+    channel: 'api' | 'portal';
+    registerName: string;
+    status: 'COMPLETED' | 'REFUNDED';
+    refundDelta: number | null;
+    /** Puntos ganados que el cliente ya había gastado al devolver la venta. */
+    pointsNotRecovered: number;
+    refundedAt: string | null;
+    createdAt: string;
+}
+export interface PosQuote {
+    customerId: string;
+    currency: 'GTQ' | 'USD';
+    amountInCents: number;
+    pointsRedeemed: number;
+    discountInCents: number;
+    totalInCents: number;
+    pointsEarned: number;
+    balanceAfter: number;
+    maxRedeemPoints: number;
+}
+export interface PosSaleInput {
+    customerId: string;
+    /** Número de ticket o factura: identifica la venta, un reintento con el mismo número no duplica puntos. */
+    receiptNumber: string;
+    amountInCents: number;
+    redeemPoints?: number;
+    currency?: 'GTQ' | 'USD';
+}
+export interface Page<T> {
+    items: T[];
+    total: number;
+    page: number;
+    pageSize: number;
+}
+export interface WebhookEvent<T = Record<string, unknown>> {
+    id: string;
+    type: 'member.created' | 'member.updated' | 'member.deactivated' | 'member.saved' | 'member.removed' | 'points.changed' | 'sale.created' | 'sale.refunded' | 'company.approved' | 'company.suspended' | 'notification.sent' | 'webhook.test';
+    mode: 'test' | 'live';
+    createdAt: string;
+    data: T;
+}
+export declare class WalletError extends Error {
+    readonly status: number;
+    /** Código estable, p. ej. `insufficient_points`, `demo_limit_reached`, `member_not_found`. */
+    readonly code: string | undefined;
+    readonly body: unknown;
+    constructor(status: number, message: string, 
+    /** Código estable, p. ej. `insufficient_points`, `demo_limit_reached`, `member_not_found`. */
+    code: string | undefined, body: unknown);
+}
+export interface WalletOptions {
+    /** Llave `sk_test_…` o `sk_live_…` (una llave de caja solo puede usar `pos`). */
+    apiKey: string;
+    /** URL base de la API, p. ej. https://wallet.miempresa.com */
+    baseUrl: string;
+    fetch?: typeof fetch;
+    /** Reintentos ante errores de red o 5xx/429 (por defecto 2). */
+    retries?: number;
+}
+export declare class Wallet {
+    private readonly options;
+    readonly members: MembersApi;
+    readonly messages: MessagesApi;
+    readonly pos: PosApi;
+    private readonly baseUrl;
+    private readonly fetchFn;
+    constructor(options: WalletOptions);
+    /** Empresa y modo de la llave. */
+    me(): Promise<{
+        company: {
+            id: string;
+            name: string;
+            slug: string;
+            status: string;
+        };
+        mode: string;
+        joinUrl: string;
+    }>;
+    /** @internal */
+    request<T>(method: string, path: string, body?: unknown, headers?: Record<string, string>): Promise<T>;
+}
+declare class MembersApi {
+    private readonly client;
+    constructor(client: Wallet);
+    /** Crea o actualiza el miembro (idempotente). Devuelve los links para guardar la tarjeta. */
+    upsert(customerId: string, input: {
+        name: string;
+        email?: string | null;
+    }): Promise<MemberDetail>;
+    get(customerId: string): Promise<MemberDetail>;
+    list(params?: {
+        page?: number;
+        pageSize?: number;
+    }): Promise<Page<Member>>;
+    deactivate(customerId: string): Promise<Member>;
+    /**
+     * Suma (delta > 0) o resta (delta < 0) puntos. Usa siempre `idempotencyKey` (p. ej. el nº de venta)
+     * para que un reintento no duplique puntos.
+     */
+    addPoints(customerId: string, input: {
+        delta: number;
+        reason?: string;
+        idempotencyKey?: string;
+    }): Promise<{
+        transaction: PointTransaction;
+        member: Member;
+    }>;
+    transactions(customerId: string, params?: {
+        page?: number;
+        pageSize?: number;
+    }): Promise<Page<PointTransaction>>;
+}
+/**
+ * Notificaciones push en Google Wallet. Google permite 3 por tarjeta cada 24 h (las campañas cuentan);
+ * por encima del límite la API responde 429 `notification_limit`.
+ */
+declare class MessagesApi {
+    private readonly client;
+    constructor(client: Wallet);
+    /** Mensaje con notificación a un cliente. */
+    sendToMember(customerId: string, input: MessageInput): Promise<Notification>;
+    /** Campaña a todos los clientes del programa. */
+    broadcast(input: MessageInput): Promise<Notification>;
+    list(params?: {
+        page?: number;
+        pageSize?: number;
+    }): Promise<Page<Notification>>;
+}
+/**
+ * Cajas registradoras: los puntos los calcula la plataforma con las reglas configuradas en el portal.
+ * El QR de la tarjeta contiene el `customerId`.
+ */
+declare class PosApi {
+    private readonly client;
+    constructor(client: Wallet);
+    /** Cliente escaneado: saldo, nivel y valor de sus puntos en dinero. */
+    customer(customerId: string): Promise<{
+        customerId: string;
+        name: string;
+        points: number;
+        tier: string | null;
+        state: "ACTIVE" | "INACTIVE";
+        currency: "GTQ" | "USD" | null;
+        pointsValueInCents: number;
+    }>;
+    /** Antes de cobrar: descuento por los puntos a canjear y puntos que dará la compra. No guarda nada. */
+    quote(input: Omit<PosSaleInput, 'receiptNumber'>): Promise<PosQuote>;
+    /** Al cobrar: canjea y suma en una sola operación. */
+    createSale(input: PosSaleInput): Promise<{
+        sale: PosSale;
+        member: Member;
+        replayed: boolean;
+    }>;
+    getSale(receiptNumber: string): Promise<PosSale>;
+    /** Devolución total del ticket: quita los puntos ganados y regresa los canjeados. */
+    refund(receiptNumber: string): Promise<{
+        sale: PosSale;
+        member: Member;
+        replayed: boolean;
+    }>;
+}
+/**
+ * Verifica la cabecera `Wallet-Signature` de un webhook y devuelve el evento.
+ * `rawBody` debe ser el cuerpo exacto recibido (sin re-serializar).
+ */
+export declare function verifyWebhook<T = Record<string, unknown>>(rawBody: string | Buffer, signatureHeader: string | undefined, secret: string, toleranceSeconds?: number): WebhookEvent<T>;
+export {};

package/dist/index.js

@@ -0,0 +1,179 @@
+/**
+ * @dinnger/wallet: cliente de Node.js para la API de tarjetas de lealtad en Google Wallet.
+ * Miembros y puntos, cajas registradoras, notificaciones y verificación de webhooks.
+ */
+import { createHmac, timingSafeEqual } from 'node:crypto';
+export class WalletError extends Error {
+    status;
+    code;
+    body;
+    constructor(status, message, 
+    /** Código estable, p. ej. `insufficient_points`, `demo_limit_reached`, `member_not_found`. */
+    code, body) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.body = body;
+        this.name = 'WalletError';
+    }
+}
+export class Wallet {
+    options;
+    members;
+    messages;
+    pos;
+    baseUrl;
+    fetchFn;
+    constructor(options) {
+        this.options = options;
+        if (!/^sk_(test|live)_/.test(options.apiKey))
+            throw new Error('apiKey debe empezar con sk_test_ o sk_live_');
+        this.baseUrl = options.baseUrl.replace(/\/$/, '');
+        this.fetchFn = options.fetch ?? fetch;
+        this.members = new MembersApi(this);
+        this.messages = new MessagesApi(this);
+        this.pos = new PosApi(this);
+    }
+    /** Empresa y modo de la llave. */
+    me() {
+        return this.request('GET', '/v1/me');
+    }
+    /** @internal */
+    async request(method, path, body, headers = {}) {
+        const retries = this.options.retries ?? 2;
+        for (let attempt = 0;; attempt++) {
+            let res;
+            try {
+                res = await this.fetchFn(`${this.baseUrl}${path}`, {
+                    method,
+                    headers: {
+                        Authorization: `Bearer ${this.options.apiKey}`,
+                        ...(body !== undefined ? { 'Content-Type': 'application/json' } : {}),
+                        ...headers,
+                    },
+                    body: body !== undefined ? JSON.stringify(body) : undefined,
+                });
+            }
+            catch (err) {
+                if (attempt < retries) {
+                    await delay(attempt);
+                    continue;
+                }
+                throw err;
+            }
+            if ((res.status >= 500 || res.status === 429) && attempt < retries) {
+                await delay(attempt);
+                continue;
+            }
+            const data = await res.json().catch(() => undefined);
+            if (!res.ok) {
+                throw new WalletError(res.status, data?.error ?? res.statusText, data?.code, data);
+            }
+            return data;
+        }
+    }
+}
+class MembersApi {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    /** Crea o actualiza el miembro (idempotente). Devuelve los links para guardar la tarjeta. */
+    upsert(customerId, input) {
+        return this.client.request('PUT', `/v1/members/${encodeURIComponent(customerId)}`, input);
+    }
+    get(customerId) {
+        return this.client.request('GET', `/v1/members/${encodeURIComponent(customerId)}`);
+    }
+    list(params = {}) {
+        const qs = new URLSearchParams(Object.entries(params).map(([k, v]) => [k, String(v)])).toString();
+        return this.client.request('GET', `/v1/members${qs ? `?${qs}` : ''}`);
+    }
+    deactivate(customerId) {
+        return this.client.request('DELETE', `/v1/members/${encodeURIComponent(customerId)}`);
+    }
+    /**
+     * Suma (delta > 0) o resta (delta < 0) puntos. Usa siempre `idempotencyKey` (p. ej. el nº de venta)
+     * para que un reintento no duplique puntos.
+     */
+    addPoints(customerId, input) {
+        return this.client.request('POST', `/v1/members/${encodeURIComponent(customerId)}/points`, input);
+    }
+    transactions(customerId, params = {}) {
+        const qs = new URLSearchParams(Object.entries(params).map(([k, v]) => [k, String(v)])).toString();
+        return this.client.request('GET', `/v1/members/${encodeURIComponent(customerId)}/transactions${qs ? `?${qs}` : ''}`);
+    }
+}
+/**
+ * Notificaciones push en Google Wallet. Google permite 3 por tarjeta cada 24 h (las campañas cuentan);
+ * por encima del límite la API responde 429 `notification_limit`.
+ */
+class MessagesApi {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    /** Mensaje con notificación a un cliente. */
+    sendToMember(customerId, input) {
+        return this.client.request('POST', `/v1/members/${encodeURIComponent(customerId)}/messages`, input);
+    }
+    /** Campaña a todos los clientes del programa. */
+    broadcast(input) {
+        return this.client.request('POST', '/v1/messages', input);
+    }
+    list(params = {}) {
+        const qs = new URLSearchParams(Object.entries(params).map(([k, v]) => [k, String(v)])).toString();
+        return this.client.request('GET', `/v1/messages${qs ? `?${qs}` : ''}`);
+    }
+}
+/**
+ * Cajas registradoras: los puntos los calcula la plataforma con las reglas configuradas en el portal.
+ * El QR de la tarjeta contiene el `customerId`.
+ */
+class PosApi {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    /** Cliente escaneado: saldo, nivel y valor de sus puntos en dinero. */
+    customer(customerId) {
+        return this.client.request('GET', `/v1/pos/members/${encodeURIComponent(customerId)}`);
+    }
+    /** Antes de cobrar: descuento por los puntos a canjear y puntos que dará la compra. No guarda nada. */
+    quote(input) {
+        return this.client.request('POST', '/v1/pos/quote', input);
+    }
+    /** Al cobrar: canjea y suma en una sola operación. */
+    createSale(input) {
+        return this.client.request('POST', '/v1/pos/sales', input);
+    }
+    getSale(receiptNumber) {
+        return this.client.request('GET', `/v1/pos/sales/${encodeURIComponent(receiptNumber)}`);
+    }
+    /** Devolución total del ticket: quita los puntos ganados y regresa los canjeados. */
+    refund(receiptNumber) {
+        return this.client.request('POST', `/v1/pos/sales/${encodeURIComponent(receiptNumber)}/refund`);
+    }
+}
+function delay(attempt) {
+    return new Promise((r) => setTimeout(r, 200 * 2 ** attempt));
+}
+/**
+ * Verifica la cabecera `Wallet-Signature` de un webhook y devuelve el evento.
+ * `rawBody` debe ser el cuerpo exacto recibido (sin re-serializar).
+ */
+export function verifyWebhook(rawBody, signatureHeader, secret, toleranceSeconds = 300) {
+    const body = typeof rawBody === 'string' ? rawBody : rawBody.toString('utf8');
+    const parts = Object.fromEntries((signatureHeader ?? '').split(',').map((p) => p.split('=', 2)));
+    const t = Number(parts.t);
+    if (!t || !parts.v1)
+        throw new Error('Cabecera Wallet-Signature inválida');
+    if (Math.abs(Date.now() / 1000 - t) > toleranceSeconds)
+        throw new Error('Webhook fuera de la ventana de tiempo');
+    const expected = createHmac('sha256', secret).update(`${t}.${body}`).digest();
+    const received = Buffer.from(parts.v1, 'hex');
+    if (received.length !== expected.length || !timingSafeEqual(received, expected)) {
+        throw new Error('Firma de webhook inválida');
+    }
+    return JSON.parse(body);
+}

package/package.json

@@ -1,6 +1,53 @@
 {
   "name": "@dinnger/wallet",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.0.1",
+  "description": "Cliente de Node.js para emitir tarjetas de lealtad en Google Wallet: clientes, puntos, cajas, notificaciones y webhooks.",
+  "keywords": [
+    "google-wallet",
+    "wallet",
+    "loyalty",
+    "lealtad",
+    "puntos",
+    "pos",
+    "webhooks"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Dinnger-IA/loyalty.git",
+    "directory": "packages/wallet"
+  },
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "sideEffects": false,
+  "engines": {
+    "node": ">=20.19"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.build.json",
+    "test": "vitest",
+    "type-check": "tsc --noEmit",
+    "prepack": "npm run build",
+    "prepublishOnly": "npm run type-check && vitest --run"
+  },
+  "devDependencies": {
+    "@types/node": "^24.19.1",
+    "typescript": "~6.0.0",
+    "vitest": "^5.0.3"
+  }
 }