@belticlabs/agent-risk-sdk 0.1.0

package/dist/middleware-_DSwvNIx.d.ts

@@ -0,0 +1,40 @@
+import { x402ResourceServer, x402HTTPResourceServer, PaywallConfig, RoutesConfig } from '@x402/core/server';
+import { B as Beltic } from './client-CVx9LgJC.js';
+import { Decision } from './api.js';
+import { c as SessionBorn, S as Session } from './session-BMNB1N1g.js';
+
+interface CorrelationContext {
+    path: string;
+    method: string;
+    header: (name: string) => string | undefined;
+}
+interface AttachOptions {
+    /** A key the merchant will see again at verify time, for delegated flows (GAP-31). */
+    correlate?: ((ctx: CorrelationContext) => string | null) | undefined;
+    /** Called with every decision; the default logs nothing. */
+    onDecision?: ((d: {
+        sessionId: string;
+        decision: Decision;
+        reasonCodes: string[];
+        born: SessionBorn;
+    }) => void) | undefined;
+}
+interface AttachedX402 {
+    /** Sessions resolved at verify time, keyed by payment digest — for tests and settle hooks. */
+    readonly inFlight: ReadonlyMap<string, Session>;
+}
+declare function attachX402(beltic: Beltic, server: x402ResourceServer, http?: x402HTTPResourceServer, opts?: AttachOptions): AttachedX402;
+
+/**
+ * The seller half as one middleware: the framework's `@x402/*` payment
+ * middleware over an `x402HTTPResourceServer` with the Beltic hooks
+ * attached. `@belticlabs/agent-risk-sdk/hono` and `@belticlabs/agent-risk-sdk/express` differ only in
+ * which `paymentMiddlewareFromHTTPServer` they hand in.
+ */
+
+type GuardedMiddlewareOptions = AttachOptions & {
+    paywall?: PaywallConfig | undefined;
+};
+declare function guardedPaymentMiddleware<M>(fromHTTPServer: (http: x402HTTPResourceServer, paywall?: PaywallConfig) => M, beltic: Beltic, routes: RoutesConfig, server: x402ResourceServer, opts?: GuardedMiddlewareOptions): M;
+
+export { type AttachOptions as A, type CorrelationContext as C, type GuardedMiddlewareOptions as G, attachX402 as a, type AttachedX402 as b, guardedPaymentMiddleware as g };

package/dist/seller/anti-fraud-gateway.d.ts

@@ -0,0 +1,32 @@
+import { B as Beltic } from '../client-CVx9LgJC.js';
+import './api.js';
+import '../session-BMNB1N1g.js';
+import './base58.js';
+
+interface PaymentRiskContext {
+    wallet: string;
+    resource: string;
+    amountAtomic: string;
+    asset: string;
+    network: string;
+    paymentIdentifier?: string;
+    /** Not in the platform port yet — pass it when you have it. */
+    sessionId?: string;
+    payTo?: string;
+}
+type RiskDecision = {
+    allow: true;
+} | {
+    allow: false;
+    reason: string;
+};
+interface AntiFraudGateway {
+    assess(context: PaymentRiskContext): Promise<RiskDecision>;
+}
+declare class BelticAntiFraudGateway implements AntiFraudGateway {
+    private readonly beltic;
+    constructor(beltic: Beltic);
+    assess(ctx: PaymentRiskContext): Promise<RiskDecision>;
+}
+
+export { type AntiFraudGateway, BelticAntiFraudGateway, type PaymentRiskContext, type RiskDecision };

package/dist/seller/anti-fraud-gateway.js

@@ -0,0 +1,39 @@
+import {
+  x402Currency
+} from "../chunk-U5Z5Z2BQ.js";
+import {
+  presentedFrom
+} from "../chunk-7G5EHNVW.js";
+import "../chunk-FQDHFTVR.js";
+import {
+  Verdict
+} from "../chunk-GCKCAKHA.js";
+
+// src/seller/anti-fraud-gateway.ts
+var BelticAntiFraudGateway = class {
+  constructor(beltic) {
+    this.beltic = beltic;
+  }
+  async assess(ctx) {
+    const session = await this.beltic.sessions.ensure(ctx.sessionId ?? null);
+    const payment = {
+      protocol: "x402",
+      payee: ctx.payTo ?? ctx.resource,
+      amount: { value: ctx.amountAtomic, currency: x402Currency(ctx.network, ctx.asset) },
+      payer: ctx.wallet.toLowerCase()
+    };
+    await session.emit(
+      "payment.presented",
+      presentedFrom(payment, {
+        resource: ctx.resource,
+        ...ctx.paymentIdentifier ? { paymentIdentifier: ctx.paymentIdentifier } : {}
+      })
+    );
+    const out = await this.beltic.evaluate(session.id, payment);
+    const verdict = Verdict.of(out.decision);
+    return verdict.blocks(this.beltic.onReview) ? { allow: false, reason: `${out.decision}:${out.reasonCodes.join(",")}` } : { allow: true };
+  }
+};
+export {
+  BelticAntiFraudGateway
+};

package/dist/session-BMNB1N1g.d.ts

@@ -0,0 +1,184 @@
+import { Signer } from './base58.js';
+import { EvidenceAck, EventResult, EvidenceEvent, EvidenceSource, WireEvidenceKind, JsonObject, ChainHead, PayloadByKind, SessionClosePayload, DeclaredIntent } from './api.js';
+
+interface ApiClientOptions {
+    baseUrl: string;
+    apiKey: string;
+    fetch?: typeof globalThis.fetch;
+    timeoutMs?: number;
+    userAgent?: string;
+}
+declare class BelticApiError extends Error {
+    readonly status: number;
+    readonly code: string;
+    readonly details?: unknown | undefined;
+    readonly requestId?: string | undefined;
+    constructor(status: number, code: string, message: string, details?: unknown | undefined, requestId?: string | undefined);
+    /** 5xx and network failures are retried by the transport; 4xx are not. */
+    get retryable(): boolean;
+}
+declare class ApiClient {
+    private readonly baseUrl;
+    private readonly fetchImpl;
+    private readonly timeoutMs;
+    private readonly headers;
+    constructor(opts: ApiClientOptions);
+    post<T>(path: string, body: unknown, headers?: Record<string, string>): Promise<T>;
+    get<T>(path: string, query?: Record<string, string | undefined>): Promise<T>;
+    private request;
+}
+
+interface AgentIdentity {
+    did: string;
+    signer: Signer;
+    /** Opaque credential presented at session start (stored, not verified this phase). */
+    credential?: string;
+}
+declare function identityFromSeed(seed: Uint8Array, credential?: string): AgentIdentity;
+declare function ephemeralIdentity(credential?: string): AgentIdentity;
+/** A JSON keystore on disk: `{ "seed": "<64 hex>" }`, created 0600 when missing. */
+declare function fileIdentity(path: string, credential?: string): AgentIdentity;
+
+/**
+ * Transport (Fraud SDK RFC › Modules: "buffering, batching, chained delivery
+ * to the Collector"). Contract as assumed in GAP-18/38: one FIFO per
+ * chain; at most one batch in flight per chain, so order is preserved;
+ * exponential backoff on network / 5xx; a `fork` or `rejected` ack halts
+ * the chain and surfaces `ChainRejectedError` — an SDK must not silently
+ * keep chaining onto a head the platform never accepted.
+ */
+
+interface TransportOptions {
+    maxBatch: number;
+    flushMs: number;
+    /** Total buffered events across chains; beyond this new events are dropped (GAP-38). */
+    maxBuffered: number;
+    backoff: {
+        baseMs: number;
+        maxMs: number;
+        maxAttempts: number;
+    };
+    onAck?: (ack: EvidenceAck) => void;
+    onError?: (err: Error) => void;
+    onChainHalted?: (err: ChainRejectedError) => void;
+    setTimeout?: typeof globalThis.setTimeout;
+    clearTimeout?: typeof globalThis.clearTimeout;
+}
+declare const DEFAULT_TRANSPORT: TransportOptions;
+declare class ChainRejectedError extends Error {
+    readonly sessionId: string;
+    readonly source: string;
+    readonly result: EventResult;
+    constructor(sessionId: string, source: string, result: EventResult);
+}
+declare class TransportClosedError extends Error {
+    constructor();
+}
+declare class Transport {
+    private readonly api;
+    private readonly opts;
+    private readonly chains;
+    private buffered;
+    private timer;
+    private closed;
+    private inFlightCount;
+    private drainWaiters;
+    constructor(api: ApiClient, opts?: Partial<TransportOptions>);
+    get size(): number;
+    hasRoom(): boolean;
+    haltedError(sessionId: string, source: string): ChainRejectedError | null;
+    /** Callers check `hasRoom()` first and assign `seq` only then (GAP-38). */
+    enqueue(ev: EvidenceEvent): void;
+    /** Send everything pending and wait for every in-flight batch to settle (ack or halt). */
+    flush(): Promise<void>;
+    close(): Promise<void>;
+    private schedule;
+    private unschedule;
+    private drained;
+    private settleWaiters;
+    private flushChain;
+    private send;
+}
+
+/**
+ * A risk session as the SDK sees it: one chain per (sessionId, source),
+ * built at the edge (Fraud SDK RFC › Wire contract). The buyer half opens
+ * AGENT_TRACE sessions and announces them with `session.open` (seq 0) and
+ * `intent.declared` (seq 1; GAP-23/60); the seller half attaches to a bound
+ * session or opens its own INTERNAL_NETWORK session (GAP-13).
+ *
+ * `seq` is handed out only when the transport has room for the event
+ * (GAP-38): a dropped event never leaves a hole — the next accepted event
+ * is preceded by a `transport.gap` that counts the drops. `redact` is off
+ * by default (GAP-33).
+ */
+
+type RedactFn = (kind: WireEvidenceKind, payload: JsonObject) => JsonObject;
+/** Who created the session — the seller half treats a bound session as buyer-born. */
+type SessionBorn = 'buyer' | 'seller';
+interface SessionDeps {
+    transport: Transport;
+    signer?: Signer | undefined;
+    redact?: RedactFn | undefined;
+    now?: (() => Date) | undefined;
+    /** Called once the session closed, so the registry can forget it. */
+    onClosed?: ((session: Session) => void) | undefined;
+}
+declare class Session {
+    private readonly deps;
+    readonly id: string;
+    readonly source: EvidenceSource;
+    readonly expiresAt: string | null;
+    readonly born: SessionBorn;
+    private chain;
+    private building;
+    private dropped;
+    private droppedFirstTs;
+    private droppedLastTs;
+    private closed;
+    private readonly now;
+    constructor(deps: SessionDeps, id: string, source: EvidenceSource, expiresAt: string | null, born: SessionBorn);
+    get head(): ChainHead | null;
+    get droppedCount(): number;
+    /** Resolves once the event is sequenced and buffered — not once it is acknowledged. */
+    emit<K extends WireEvidenceKind>(kind: K, payload: PayloadByKind[K]): Promise<boolean>;
+    close(reason?: SessionClosePayload['reason'], extra?: JsonObject): Promise<void>;
+    /** Read-your-writes: the platform must hold the evidence before anyone judges it (GAP-16/66). */
+    flush(): Promise<void>;
+    /** Serialized: two concurrent emits get consecutive seqs, never the same one. */
+    private next;
+}
+interface StartSessionInput {
+    intent?: DeclaredIntent;
+    runtime?: {
+        framework?: string;
+        model?: string;
+    };
+    attestations?: JsonObject;
+}
+interface SessionsDeps {
+    api: ApiClient;
+    transport: Transport;
+    identity?: AgentIdentity | undefined;
+    redact?: RedactFn | undefined;
+    now?: (() => Date) | undefined;
+    sdkVersion: string;
+}
+declare class Sessions {
+    private readonly deps;
+    /**
+     * One session object per (session, source) per process: a chain's head
+     * lives in it, so two objects for the same chain would both start at
+     * seq 0 and fork it. Closed sessions are forgotten; a process restart
+     * mid-session still loses the head (GAP-67).
+     */
+    private readonly attached;
+    constructor(deps: SessionsDeps);
+    /** Buyer half: create an AGENT_TRACE session bound to the agent identity, then announce it on the chain. */
+    start(input?: StartSessionInput): Promise<Session>;
+    /** Seller half: emit INTERNAL_NETWORK evidence into a session the buyer bound, or open a seller-born one. */
+    ensure(sessionId?: string | null): Promise<Session>;
+    private attach;
+}
+
+export { type AgentIdentity as A, BelticApiError as B, ChainRejectedError as C, DEFAULT_TRANSPORT as D, type RedactFn as R, Session as S, Transport as T, ApiClient as a, type ApiClientOptions as b, type SessionBorn as c, Sessions as d, type StartSessionInput as e, TransportClosedError as f, type TransportOptions as g, ephemeralIdentity as h, fileIdentity as i, identityFromSeed as j };

package/dist/x402/express.d.ts

@@ -0,0 +1,14 @@
+import { RoutesConfig, x402ResourceServer } from '@x402/core/server';
+import { RequestHandler } from 'express';
+import { B as Beltic } from '../client-CVx9LgJC.js';
+import { G as GuardedMiddlewareOptions } from '../middleware-_DSwvNIx.js';
+export { a as attachX402 } from '../middleware-_DSwvNIx.js';
+import './api.js';
+import '../session-BMNB1N1g.js';
+import './base58.js';
+
+/** Seller half for express: `@x402/express`'s payment middleware with the Beltic hooks attached. */
+
+declare function belticPaymentMiddleware(beltic: Beltic, routes: RoutesConfig, server: x402ResourceServer, opts?: GuardedMiddlewareOptions): RequestHandler;
+
+export { belticPaymentMiddleware };

package/dist/x402/express.js

@@ -0,0 +1,26 @@
+import {
+  attachX402,
+  guardedPaymentMiddleware
+} from "../chunk-YVMJ5CZX.js";
+import "../chunk-VM7MK43J.js";
+import "../chunk-SFGM7KOG.js";
+import "../chunk-U5Z5Z2BQ.js";
+import "../chunk-7G5EHNVW.js";
+import "../chunk-FQDHFTVR.js";
+import "../chunk-GCKCAKHA.js";
+
+// src/x402/express.ts
+import { paymentMiddlewareFromHTTPServer } from "@x402/express";
+function belticPaymentMiddleware(beltic, routes, server, opts) {
+  return guardedPaymentMiddleware(
+    paymentMiddlewareFromHTTPServer,
+    beltic,
+    routes,
+    server,
+    opts
+  );
+}
+export {
+  attachX402,
+  belticPaymentMiddleware
+};

package/dist/x402/hono.d.ts

@@ -0,0 +1,14 @@
+import { RoutesConfig, x402ResourceServer } from '@x402/core/server';
+import { MiddlewareHandler } from 'hono';
+import { B as Beltic } from '../client-CVx9LgJC.js';
+import { G as GuardedMiddlewareOptions } from '../middleware-_DSwvNIx.js';
+export { a as attachX402 } from '../middleware-_DSwvNIx.js';
+import './api.js';
+import '../session-BMNB1N1g.js';
+import './base58.js';
+
+/** Seller half for hono: `@x402/hono`'s payment middleware with the Beltic hooks attached. */
+
+declare function belticPaymentMiddleware(beltic: Beltic, routes: RoutesConfig, server: x402ResourceServer, opts?: GuardedMiddlewareOptions): MiddlewareHandler;
+
+export { belticPaymentMiddleware };

package/dist/x402/hono.js

@@ -0,0 +1,20 @@
+import {
+  attachX402,
+  guardedPaymentMiddleware
+} from "../chunk-YVMJ5CZX.js";
+import "../chunk-VM7MK43J.js";
+import "../chunk-SFGM7KOG.js";
+import "../chunk-U5Z5Z2BQ.js";
+import "../chunk-7G5EHNVW.js";
+import "../chunk-FQDHFTVR.js";
+import "../chunk-GCKCAKHA.js";
+
+// src/x402/hono.ts
+import { paymentMiddlewareFromHTTPServer } from "@x402/hono";
+function belticPaymentMiddleware(beltic, routes, server, opts) {
+  return guardedPaymentMiddleware(paymentMiddlewareFromHTTPServer, beltic, routes, server, opts);
+}
+export {
+  attachX402,
+  belticPaymentMiddleware
+};

package/dist/x402/index.d.ts

@@ -0,0 +1,54 @@
+export { A as AttachOptions, b as AttachedX402, C as CorrelationContext, G as GuardedMiddlewareOptions, a as attachX402, g as guardedPaymentMiddleware } from '../middleware-_DSwvNIx.js';
+import { S as Session } from '../session-BMNB1N1g.js';
+import { PaymentMomentPayload, JsonObject } from './api.js';
+import { PaymentPayload, PaymentRequired, PaymentRequirements } from '@x402/core/types';
+import '@x402/core/server';
+import '../client-CVx9LgJC.js';
+import './base58.js';
+
+/**
+ * Session binding on the x402 rail (Fraud SDK RFC › Protocol Adapter — x402:
+ * "`PAYMENT-SIGNATURE` extension `beltic.sessionId`"). Where exactly it
+ * lives is GAP-30; that it is outside the wallet-signed payload is GAP-56.
+ */
+declare const SESSION_EXTENSION = "beltic.sessionId";
+declare const SESSION_HEADER = "Beltic-Session-Id";
+declare function sessionIdOf(extensions: Readonly<Record<string, unknown>> | undefined): string | null;
+
+declare function belticFetch(session: Session, inner?: typeof globalThis.fetch): typeof globalThis.fetch;
+
+/**
+ * x402 artifacts → protocol moments (Fraud SDK RFC › Protocol Adapter —
+ * x402). The moment is normalized (payee, amount, payer) so both sides of
+ * a purchase compare; the artifact travels whole in `raw`. For x402 the
+ * currency is `<network>/<asset>` (GAP-49) and the value is the atomic
+ * amount as the protocol carries it.
+ */
+
+type Readonlyish<T> = {
+    readonly [K in keyof T]: Readonlyish<T[K]>;
+} | T;
+declare function x402Currency(network: string, asset: string): string;
+/** The minimum an `accepts` entry needs to become a moment; unknown parts are named, never dropped. */
+interface AcceptsLike {
+    payTo?: string | undefined;
+    amount?: string | undefined;
+    network?: string | undefined;
+    asset?: string | undefined;
+}
+/** The payer is scheme-specific; the common EVM shapes are read, anything else stays in `raw`. */
+declare function payerOf(payload: Readonlyish<PaymentPayload>): string | undefined;
+declare const x402Moments: {
+    /** The 402 challenge as the buyer saw it. */
+    required(required: Readonlyish<PaymentRequired>): PaymentMomentPayload;
+    /** The requirements the seller's resource server resolved for a request. */
+    requirements(req: Readonlyish<PaymentRequirements>): PaymentMomentPayload;
+    /** A route's static `accepts` config, before any payment header exists. */
+    route(route: unknown, raw: JsonObject): PaymentMomentPayload;
+    /** An in-band ask (MRTR `input_required` or a `_meta` envelope) carrying an x402-style `accepts`. */
+    ask(first: AcceptsLike, raw: JsonObject): PaymentMomentPayload;
+    /** The signed payment the buyer presented. */
+    payload(payload: Readonlyish<PaymentPayload>): PaymentMomentPayload;
+};
+
+export { type AcceptsLike, SESSION_EXTENSION, SESSION_HEADER, belticFetch, payerOf, sessionIdOf, x402Currency, x402Moments };

package/dist/x402/index.js

@@ -0,0 +1,67 @@
+import {
+  attachX402,
+  guardedPaymentMiddleware
+} from "../chunk-YVMJ5CZX.js";
+import {
+  SESSION_EXTENSION,
+  SESSION_HEADER,
+  sessionIdOf
+} from "../chunk-VM7MK43J.js";
+import "../chunk-SFGM7KOG.js";
+import {
+  payerOf,
+  x402Currency,
+  x402Moments
+} from "../chunk-U5Z5Z2BQ.js";
+import "../chunk-7G5EHNVW.js";
+import "../chunk-FQDHFTVR.js";
+import "../chunk-GCKCAKHA.js";
+
+// src/x402/fetch.ts
+import {
+  decodePaymentRequiredHeader,
+  decodePaymentSignatureHeader,
+  encodePaymentSignatureHeader
+} from "@x402/core/http";
+function belticFetch(session, inner = globalThis.fetch) {
+  return async (input, init) => {
+    const headers = new Headers(
+      init?.headers ?? (input instanceof Request ? input.headers : void 0)
+    );
+    headers.set(SESSION_HEADER, session.id);
+    const sigHeader = headers.get("PAYMENT-SIGNATURE");
+    if (sigHeader) {
+      try {
+        const payload = decodePaymentSignatureHeader(sigHeader);
+        payload.extensions = { ...payload.extensions ?? {}, [SESSION_EXTENSION]: session.id };
+        headers.set("PAYMENT-SIGNATURE", encodePaymentSignatureHeader(payload));
+        await session.emit("payment.presented", x402Moments.payload(payload));
+        await session.flush();
+      } catch {
+      }
+    }
+    const res = await inner(input, { ...init, headers });
+    const required = res.status === 402 ? res.headers.get("PAYMENT-REQUIRED") : null;
+    if (required) {
+      try {
+        await session.emit(
+          "payment.requested",
+          x402Moments.required(decodePaymentRequiredHeader(required))
+        );
+      } catch {
+      }
+    }
+    return res;
+  };
+}
+export {
+  SESSION_EXTENSION,
+  SESSION_HEADER,
+  attachX402,
+  belticFetch,
+  guardedPaymentMiddleware,
+  payerOf,
+  sessionIdOf,
+  x402Currency,
+  x402Moments
+};

package/package.json

@@ -0,0 +1,106 @@
+{
+  "name": "@belticlabs/agent-risk-sdk",
+  "version": "0.1.0",
+  "description": "The Beltic Agent Risk SDK — one client, two halves: instrument the buyer agent (AI SDK, x402 fetch, MCP client) and guard the seller boundary (x402, MCP server, evaluate).",
+  "license": "UNLICENSED",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/belticlabs/agent-risk-platform.git",
+    "directory": "packages/sdk"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./ai": {
+      "types": "./dist/ai/index.d.ts",
+      "default": "./dist/ai/index.js"
+    },
+    "./x402": {
+      "types": "./dist/x402/index.d.ts",
+      "default": "./dist/x402/index.js"
+    },
+    "./hono": {
+      "types": "./dist/x402/hono.d.ts",
+      "default": "./dist/x402/hono.js"
+    },
+    "./express": {
+      "types": "./dist/x402/express.d.ts",
+      "default": "./dist/x402/express.js"
+    },
+    "./mcp": {
+      "types": "./dist/mcp/index.d.ts",
+      "default": "./dist/mcp/index.js"
+    },
+    "./platform-adapter": {
+      "types": "./dist/seller/anti-fraud-gateway.d.ts",
+      "default": "./dist/seller/anti-fraud-gateway.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.map"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "zod": "^4.6.5"
+  },
+  "peerDependencies": {
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    "@x402/core": "^2.25.0",
+    "@x402/express": "^2.25.0",
+    "@x402/hono": "^2.25.0",
+    "ai": "^7.0.0",
+    "express": "^5.0.0",
+    "hono": "^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@modelcontextprotocol/sdk": {
+      "optional": true
+    },
+    "@x402/core": {
+      "optional": true
+    },
+    "@x402/express": {
+      "optional": true
+    },
+    "@x402/hono": {
+      "optional": true
+    },
+    "ai": {
+      "optional": true
+    },
+    "express": {
+      "optional": true
+    },
+    "hono": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    "@types/express": "^5.0.6",
+    "@x402/core": "^2.25.0",
+    "@x402/express": "^2.25.0",
+    "@x402/hono": "^2.25.0",
+    "ai": "^7.0.100",
+    "express": "^5.2.1",
+    "hono": "^4.13.7",
+    "tsup": "8.5.1",
+    "typescript": "5.9.3",
+    "@belticlabs/canon": "0.0.0",
+    "@belticlabs/protocol": "0.0.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "check-types": "tsc --noEmit -p tsconfig.json",
+    "clean": "rm -rf dist"
+  }
+}