@evomap/evolver-adapter-public 2.0.0-beta.0

package/dist/offlinePermit.js

@@ -0,0 +1,309 @@
+import { createHash, createHmac, timingSafeEqual } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { util } from '@evomap/evolver-core';
+import { AuthError, globalFetchLike, HubClientError, HubFetch } from './hubFetch.js';
+export const DEFAULT_MAX_OFFLINE_SOLIDIFIES = 10;
+export const DEFAULT_MAX_OFFLINE_DURATION_MS = 7 * 24 * 60 * 60 * 1000;
+export const DEFAULT_MAX_CLOCK_DRIFT_MS = 24 * 60 * 60 * 1000;
+const OFFLINE_TOKEN_FILE = '.ot';
+const LAST_VERIFY_FILE = '.lv';
+const LOCK_SUFFIX = '.lock';
+const ERROR_DETAIL_MAX_CHARS = 200;
+const DEFAULT_OFFLINE_PERMIT_LOCK = { maxTries: 5, waitMs: 1 };
+/**
+ * HMAC-backed local offline permit counter.
+ *
+ * This ports v1 PR #157's concurrency fix into v2: the full
+ * load -> cap-check -> increment -> write pipeline is serialized with the
+ * shared PID-liveness file lock, so daemon and CLI processes cannot both
+ * consume the same local offline quota slot.
+ */
+export class OfflinePermitStore {
+    opts;
+    now;
+    maxOfflineSolidifies;
+    maxOfflineDurationMs;
+    maxClockDriftMs;
+    constructor(opts) {
+        this.opts = opts;
+        this.now = opts.now ?? (() => Date.now());
+        this.maxOfflineSolidifies = opts.maxOfflineSolidifies ?? DEFAULT_MAX_OFFLINE_SOLIDIFIES;
+        this.maxOfflineDurationMs = opts.maxOfflineDurationMs ?? DEFAULT_MAX_OFFLINE_DURATION_MS;
+        this.maxClockDriftMs = opts.maxClockDriftMs ?? DEFAULT_MAX_CLOCK_DRIFT_MS;
+    }
+    offlineTokenPath() {
+        return join(this.opts.dir, OFFLINE_TOKEN_FILE);
+    }
+    lastVerifyPath() {
+        return join(this.opts.dir, LAST_VERIFY_FILE);
+    }
+    lockPath() {
+        return `${this.offlineTokenPath()}${LOCK_SUFFIX}`;
+    }
+    cacheOfflineToken(token) {
+        try {
+            const secret = this.nodeSecret();
+            if (!secret)
+                return false;
+            mkdirSync(dirname(this.offlineTokenPath()), { recursive: true });
+            const data = JSON.stringify(token);
+            const hmac = hmacSha256(secret, data);
+            writeFileSync(this.offlineTokenPath(), `${JSON.stringify({ data: token, hmac })}\n`, { encoding: 'utf8', mode: 0o600 });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    loadOfflineToken() {
+        try {
+            if (!existsSync(this.offlineTokenPath()))
+                return null;
+            const stored = JSON.parse(readFileSync(this.offlineTokenPath(), 'utf8'));
+            if (!isStoredOfflinePermitToken(stored))
+                return null;
+            const secret = this.nodeSecret();
+            if (!secret)
+                return null;
+            const expected = hmacSha256(secret, JSON.stringify(stored.data));
+            if (!safeHexEqual(expected, stored.hmac))
+                return null;
+            return stored.data;
+        }
+        catch {
+            return null;
+        }
+    }
+    recordLastOnlineVerify(ts = this.now()) {
+        try {
+            mkdirSync(dirname(this.lastVerifyPath()), { recursive: true });
+            writeFileSync(this.lastVerifyPath(), String(ts), { encoding: 'utf8', mode: 0o600 });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    getLastOnlineVerifyTs() {
+        try {
+            if (!existsSync(this.lastVerifyPath()))
+                return 0;
+            return Number.parseInt(readFileSync(this.lastVerifyPath(), 'utf8'), 10) || 0;
+        }
+        catch {
+            return 0;
+        }
+    }
+    consumeOfflinePermit() {
+        try {
+            mkdirSync(dirname(this.offlineTokenPath()), { recursive: true });
+        }
+        catch {
+            // Let acquireLock surface the concrete filesystem error below; it is
+            // converted to the structured offline_lock_failed envelope.
+        }
+        let locked = false;
+        try {
+            util.acquireLock(this.lockPath(), this.opts.lock ?? DEFAULT_OFFLINE_PERMIT_LOCK);
+            locked = true;
+            return this.consumeLocked();
+        }
+        catch (err) {
+            if (isLockTimeoutError(err))
+                return { ok: false, error: 'offline_permit_busy', offline: true };
+            const message = err instanceof Error ? err.message : String(err);
+            return { ok: false, error: 'offline_lock_failed', offline: true, detail: this.errorDetail(message) };
+        }
+        finally {
+            if (locked)
+                util.releaseLock(this.lockPath());
+        }
+    }
+    consumeLocked() {
+        const token = this.loadOfflineToken();
+        if (!token)
+            return { ok: false, error: 'no_offline_token', offline: true };
+        const maxSolidifies = finiteNonNegativeNumber(token.maxOfflineSolidifies, this.maxOfflineSolidifies);
+        const expiresAt = finitePositiveNumber(token.expiresAt);
+        const usedCount = finiteNonNegativeNumber(token.usedCount, 0);
+        const now = this.now();
+        const lastOnline = this.getLastOnlineVerifyTs();
+        if (lastOnline > 0 && now < lastOnline - this.maxClockDriftMs) {
+            return { ok: false, error: 'clock_drift_detected', offline: true };
+        }
+        if (expiresAt === null || now > expiresAt) {
+            return { ok: false, error: 'offline_token_expired', offline: true };
+        }
+        if (lastOnline > 0 && now - lastOnline > this.maxOfflineDurationMs) {
+            return { ok: false, error: 'offline_duration_exceeded', offline: true };
+        }
+        if (usedCount >= maxSolidifies) {
+            return { ok: false, error: 'offline_quota_exhausted', offline: true };
+        }
+        token.usedCount = usedCount + 1;
+        if (!this.cacheOfflineToken(token)) {
+            return { ok: false, error: 'offline_lock_failed', offline: true, detail: 'offline token write failed' };
+        }
+        return { ok: true, offline: true, remaining: maxSolidifies - token.usedCount };
+    }
+    nodeSecret() {
+        const raw = typeof this.opts.nodeSecret === 'function' ? this.opts.nodeSecret() : this.opts.nodeSecret;
+        return typeof raw === 'string' && raw.length > 0 ? raw : null;
+    }
+    errorDetail(message) {
+        let out = message;
+        for (const sensitive of [this.lockPath(), this.offlineTokenPath(), this.lastVerifyPath(), this.opts.dir].sort((a, b) => b.length - a.length)) {
+            if (sensitive)
+                out = out.split(sensitive).join('<offline-permit-path>');
+        }
+        return out.slice(0, ERROR_DETAIL_MAX_CHARS);
+    }
+}
+export function createSolidifyPermitCheck(opts) {
+    const store = opts.store ?? new OfflinePermitStore({
+        dir: opts.dir,
+        nodeSecret: opts.nodeSecret,
+        ...(opts.now ? { now: opts.now } : {}),
+    });
+    const http = new HubFetch({
+        baseUrl: opts.hubUrl.replace(/\/+$/, ''),
+        auth: opts.auth,
+        fetchFn: opts.fetchFn ?? globalFetchLike,
+        senderId: opts.senderId,
+    });
+    return async (ctx) => {
+        const online = await requestSolidifyPermit(http, opts, ctx, store);
+        if (online.ok)
+            return { ok: true, reason: online.reason ?? 'hub_solidify_authorized' };
+        if (!online.offline)
+            return { ok: false, reason: online.reason };
+        const offline = store.consumeOfflinePermit();
+        if (offline.ok)
+            return { ok: true, reason: 'offline_permit' };
+        return {
+            ok: false,
+            reason: `hub_solidify_offline_denied:${offline.error}`,
+            ...(offline.detail ? { detail: offline.detail } : {}),
+        };
+    };
+}
+async function requestSolidifyPermit(http, opts, ctx, store) {
+    try {
+        const body = buildVerifySolidifyBody(opts, ctx);
+        const raw = await http.call('POST', '/a2a/verify-solidify', body);
+        // Any 2xx response proves the hub's application layer answered, so the node
+        // is not actually offline — refresh lastOnlineVerify even on {ok:false}
+        // envelopes (quota_exceeded, rate_limited, validation). Previously this only
+        // fired on raw.ok===true, so a long streak of envelope errors let the
+        // offline-duration counter run past maxOfflineDurationMs (7d) and falsely
+        // trip offline_duration_exceeded while the hub was reachable the whole time.
+        // (ports v1 PR #149)
+        store.recordLastOnlineVerify(opts.now?.());
+        // Only trust an offline_token from a genuine {ok:true} envelope — an error
+        // envelope must never seed the offline-permit cache with a stale token.
+        if (raw['ok'] === true && isOfflinePermitToken(raw['offline_token'])) {
+            store.cacheOfflineToken(raw['offline_token']);
+        }
+        return normalizePermitResult(raw, false);
+    }
+    catch (err) {
+        // 4xx means the hub answered and explicitly rejected (bad auth, forbidden,
+        // client error). status < 500 still proves reachability, so refresh
+        // lastOnlineVerify here too — mirrors the non-5xx rule above. The solidify
+        // stays denied online (offline:false), so this never feeds the offline
+        // quota fallback. (ports v1 PR #149)
+        if (err instanceof AuthError) {
+            store.recordLastOnlineVerify(opts.now?.());
+            return { ok: false, offline: false, reason: `HTTP ${err.status}` };
+        }
+        if (err instanceof HubClientError) {
+            store.recordLastOnlineVerify(opts.now?.());
+            return { ok: false, offline: false, reason: permitError(rawRecord(err.body)) ?? `HTTP ${err.status}` };
+        }
+        // 5xx (plain Error), captive-portal/non-API responses (HubUnreachableError),
+        // and transport failures are genuinely offline → leave lastOnlineVerify
+        // untouched so the offline-duration guard still trips if the hub stays down.
+        return { ok: false, offline: true, reason: err instanceof Error ? err.message : String(err) };
+    }
+}
+function buildVerifySolidifyBody(opts, ctx) {
+    const ts = opts.now?.() ?? Date.now();
+    const signalsHash = hashCompact(JSON.stringify([...ctx.signals].slice(0, 8)));
+    const mutationHash = hashCompact(JSON.stringify(ctx.mutation));
+    const nodeId = opts.senderId();
+    const secret = resolveNodeSecret(opts.nodeSecret);
+    const signatureFields = secret && nodeId
+        ? {
+            client_signature: hmacSha256(createHash('sha256').update(secret).digest('hex'), [nodeId, ctx.geneId || '', signalsHash, mutationHash, String(ts)].join('|')),
+        }
+        : {};
+    return {
+        gene_id: ctx.geneId,
+        signals_hash: signalsHash,
+        mutation_hash: mutationHash,
+        ts,
+        ...signatureFields,
+    };
+}
+function hashCompact(input) {
+    return createHash('sha256').update(input).digest('hex').slice(0, 16);
+}
+function normalizePermitResult(raw, fallbackOffline) {
+    if (raw['ok'] === true)
+        return { ok: true, ...(raw['offline'] === true ? { offline: true } : {}) };
+    return { ok: false, offline: typeof raw['offline'] === 'boolean' ? raw['offline'] : fallbackOffline, reason: permitError(raw) ?? 'solidify_permit_denied' };
+}
+function permitError(raw) {
+    const value = raw?.['error'] ?? raw?.['reason'];
+    return typeof value === 'string' && value.length > 0 ? value.slice(0, ERROR_DETAIL_MAX_CHARS) : undefined;
+}
+function isOfflinePermitToken(value) {
+    return Boolean(value && typeof value === 'object');
+}
+function rawRecord(value) {
+    return value && typeof value === 'object' ? value : null;
+}
+function resolveNodeSecret(input) {
+    const raw = typeof input === 'function' ? input() : input;
+    return typeof raw === 'string' && raw.length > 0 ? raw : null;
+}
+export function hmacSha256(key, data) {
+    return createHmac('sha256', key).update(data).digest('hex');
+}
+function safeHexEqual(expected, received) {
+    try {
+        const exp = Buffer.from(expected, 'hex');
+        const got = Buffer.from(received, 'hex');
+        return exp.length === got.length && timingSafeEqual(exp, got);
+    }
+    catch {
+        return false;
+    }
+}
+function isStoredOfflinePermitToken(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const v = value;
+    return Boolean(v.data && typeof v.data === 'object' && typeof v.hmac === 'string');
+}
+function finiteNonNegativeNumber(value, fallback) {
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        return fallback;
+    return Math.max(0, Math.floor(value));
+}
+function finitePositiveNumber(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0)
+        return null;
+    return Math.floor(value);
+}
+function isLockTimeoutError(err) {
+    if (!(err instanceof Error))
+        return false;
+    const code = err.code;
+    if (code === 'LOCK_TIMEOUT')
+        return true;
+    if (code)
+        return false;
+    return /文件锁|lock/i.test(err.message);
+}

package/dist/pricing/modelPrices.d.ts

@@ -0,0 +1,16 @@
+import { ops } from '@evomap/evolver-core';
+type ModelPrice = ops.ModelPrice;
+type PriceTable = ops.PriceTable;
+/**
+ * Load the model→price map from the JSON data file. A missing or malformed file degrades to an empty map (no
+ * prices) rather than throwing — the ledger then reports tokens saved without a cost figure, never crashes.
+ * @param path override the data-file location (tests / alternate price sets); defaults to the bundled file.
+ */
+export declare function loadModelPriceMap(path?: string): Record<string, ModelPrice>;
+/**
+ * Build the injectable PriceTable from the JSON data file. This is what the composition layer hands to the
+ * value ledger's derive functions. Updating prices = editing modelPrices.json; this function and core are
+ * untouched.
+ */
+export declare function loadPriceTable(path?: string): PriceTable;
+export {};

package/dist/pricing/modelPrices.js

@@ -0,0 +1,44 @@
+// Model price DATA loader (#112). The price table is a DATA FILE (modelPrices.json) the adapter loads and
+// injects into core's value ledger as a PriceTable. Core hardcodes no price — so a price update is editing the
+// JSON next to this file, never a core code change (acceptance criterion). This loader is the only code that
+// reads the file; it tolerates a missing/corrupt file by degrading to an empty table (an unlisted model simply
+// contributes no cost to the ledger — never a thrown error in a long-running daemon).
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { ops } from '@evomap/evolver-core';
+/** Resolve the JSON data file next to this module (works from src under test and dist at runtime). */
+function defaultPricesPath() {
+    const here = dirname(fileURLToPath(import.meta.url));
+    return join(here, 'modelPrices.json');
+}
+/**
+ * Load the model→price map from the JSON data file. A missing or malformed file degrades to an empty map (no
+ * prices) rather than throwing — the ledger then reports tokens saved without a cost figure, never crashes.
+ * @param path override the data-file location (tests / alternate price sets); defaults to the bundled file.
+ */
+export function loadModelPriceMap(path = defaultPricesPath()) {
+    try {
+        const parsed = JSON.parse(readFileSync(path, 'utf8'));
+        const models = parsed.models;
+        if (!models || typeof models !== 'object')
+            return {};
+        const out = {};
+        for (const [model, price] of Object.entries(models)) {
+            if (price && typeof price === 'object')
+                out[model] = price;
+        }
+        return out;
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Build the injectable PriceTable from the JSON data file. This is what the composition layer hands to the
+ * value ledger's derive functions. Updating prices = editing modelPrices.json; this function and core are
+ * untouched.
+ */
+export function loadPriceTable(path) {
+    return ops.priceTableFromMap(loadModelPriceMap(path));
+}

package/dist/wireMap.d.ts

@@ -0,0 +1,28 @@
+import type { hub } from '@evomap/evolver-core';
+/** 公版 inbound 消息(snake_case) → core AgentEvent. */
+export declare function inboundToAgentEvent(m: Record<string, unknown>): hub.AgentEvent;
+/**
+ * SearchQuery(camelCase) → 公版 /a2a/fetch wire(snake_case). 关键: signalsAny → signals(dev 实测 hub 读
+ * payload.signals, #69)。text 不是 fetch 字段(自由文本走 semantic-search 端点, 见 hubCapability.search)。
+ */
+export declare function searchQueryToFetchWire(q: hub.HubQuery): Record<string, unknown>;
+/** core AgentEvent(出站) → 公版 outbound 消息(id+type 必填). */
+export declare function agentEventToOutbound(e: hub.AgentEvent): Record<string, unknown>;
+/** Retry policy for a non-2xx hub status, shared by every money-touching caller (anti-drift, #177). */
+export type AtpRetryClass = 'permanent' | 'cooldown' | 'recoverable';
+/**
+ * Canonical hub-status → retry policy. ONE source of truth so publish and auto-deliver can never drift on which
+ * status means what (the #177 root cause: each caller inlined its own classification).
+ *  - permanent : structurally dead, NO retry ever helps — 400 bad-request / 404 gone / 409 duplicate /
+ *                422 invalid-payload (a malformed proof fails identically forever).
+ *  - cooldown  : the hub is explicitly rate-limiting — 429. Retrying next tick violates the cooldown AND
+ *                hammers the economic endpoint, so a loop consumer MUST back off before retrying.
+ *  - recoverable: environment-recoverable, retry-later is correct — 402 credit top-up / 403 node rebind, and
+ *                5xx / network (status 0) server-side blips.
+ * A one-shot caller (publishRespToReceipt) renders ALL non-2xx as `terminal: true` regardless of class — it
+ * does not auto-retry, the human re-acts. A LOOP caller (atpAutoDeliver) applies the class: permanent → give up,
+ * cooldown → backoff, recoverable → retry next tick. Same map, different retry policy per caller.
+ */
+export declare function atpRetryClass(status: number): AtpRetryClass;
+/** /a2a/publish 响应 → PublishReceipt. 200=accepted; 402/4xx=rejected 终态. */
+export declare function publishRespToReceipt(status: number, body: Record<string, unknown>): hub.PublishReceipt;

package/dist/wireMap.js

@@ -0,0 +1,99 @@
+/** 公版 inbound 消息(snake_case) → core AgentEvent. */
+export function inboundToAgentEvent(m) {
+    return {
+        id: String(m['id'] ?? ''),
+        type: String(m['type'] ?? ''),
+        payload: m['payload'],
+        priority: m['priority'] ?? 'medium',
+        ...(m['cursor'] ? { cursor: String(m['cursor']) } : {}),
+        createdAt: typeof m['created_at'] === 'string' ? Date.parse(m['created_at']) : Number(m['created_at'] ?? 0),
+        ...(m['ref_id'] ? { refId: String(m['ref_id']) } : {}),
+    };
+}
+/**
+ * SearchQuery(camelCase) → 公版 /a2a/fetch wire(snake_case). 关键: signalsAny → signals(dev 实测 hub 读
+ * payload.signals, #69)。text 不是 fetch 字段(自由文本走 semantic-search 端点, 见 hubCapability.search)。
+ */
+export function searchQueryToFetchWire(q) {
+    const out = {};
+    if (q.signalsAny && q.signalsAny.length > 0)
+        out['signals'] = q.signalsAny;
+    if (q.kind)
+        out['kind'] = q.kind;
+    if (q.category)
+        out['category'] = q.category;
+    if (q.gene)
+        out['gene'] = q.gene;
+    if (q.limit !== undefined)
+        out['limit'] = q.limit;
+    return out;
+}
+/** core AgentEvent(出站) → 公版 outbound 消息(id+type 必填). */
+export function agentEventToOutbound(e) {
+    return {
+        id: e.id,
+        type: e.type,
+        payload: e.payload,
+        priority: e.priority,
+        ...(e.refId ? { ref_id: e.refId } : {}),
+    };
+}
+/**
+ * Canonical hub-status → retry policy. ONE source of truth so publish and auto-deliver can never drift on which
+ * status means what (the #177 root cause: each caller inlined its own classification).
+ *  - permanent : structurally dead, NO retry ever helps — 400 bad-request / 404 gone / 409 duplicate /
+ *                422 invalid-payload (a malformed proof fails identically forever).
+ *  - cooldown  : the hub is explicitly rate-limiting — 429. Retrying next tick violates the cooldown AND
+ *                hammers the economic endpoint, so a loop consumer MUST back off before retrying.
+ *  - recoverable: environment-recoverable, retry-later is correct — 402 credit top-up / 403 node rebind, and
+ *                5xx / network (status 0) server-side blips.
+ * A one-shot caller (publishRespToReceipt) renders ALL non-2xx as `terminal: true` regardless of class — it
+ * does not auto-retry, the human re-acts. A LOOP caller (atpAutoDeliver) applies the class: permanent → give up,
+ * cooldown → backoff, recoverable → retry next tick. Same map, different retry policy per caller.
+ */
+export function atpRetryClass(status) {
+    if (status === 400 || status === 404 || status === 409 || status === 422)
+        return 'permanent';
+    if (status === 429)
+        return 'cooldown';
+    return 'recoverable';
+}
+/** /a2a/publish 响应 → PublishReceipt. 200=accepted; 402/4xx=rejected 终态. */
+export function publishRespToReceipt(status, body) {
+    const payload = body['payload'] ?? body;
+    const assetIds = payload['asset_ids'];
+    const assetId = payload['asset_id'] ?? body['asset_id'] ?? assetIds?.[0];
+    const bundleId = payload['bundle_id'];
+    if (status >= 200 && status < 300) {
+        const decision = String(payload['decision'] ?? payload['status'] ?? 'accepted');
+        const accepted = decision === 'accepted' || decision === 'approved' || decision === 'ok';
+        return {
+            receiptId: String(payload['receipt_id'] ?? bundleId ?? payload['id'] ?? assetId ?? 'unknown'),
+            status: accepted ? 'accepted' : (decision === 'quarantine' ? 'quarantine' : 'rejected'),
+            ...(assetId ? { assetId } : {}),
+            ...(bundleId ? { bundleId } : {}),
+            ...(assetIds ? { assetIds } : {}),
+            ...(payload['reason'] ? { reason: String(payload['reason']) } : {}),
+            terminal: !accepted, // quarantine/rejected 终态不重试
+        };
+    }
+    // M8-1: 按语义而非纯状态码区分(都终态不重试 = money-safety: 不反复打经济端点).
+    // 402=creditShortage(余额不足) / 403=node 失效需 rebind / 409=duplicate / 422=payload 须修 / 429=cooldown.
+    const reasonByStatus = { 402: 'credit_shortage', 403: 'node_unauthorized', 409: 'duplicate', 422: 'invalid_payload', 429: 'cooldown' };
+    const receipt = {
+        receiptId: String(payload['receipt_id'] ?? 'rejected'),
+        status: 'rejected',
+        reason: String(payload['reason'] ?? reasonByStatus[status] ?? `hub ${status}`),
+        ...(assetId ? { assetId } : {}),
+        terminal: true,
+    };
+    if (status === 402) {
+        receipt.economic = {
+            creditShortage: true,
+            ...(payload['required'] !== undefined ? { required: Number(payload['required']) } : {}),
+            ...(payload['available'] !== undefined ? { available: Number(payload['available']) } : {}),
+            ...(payload['balance_kind'] ? { balanceKind: payload['balance_kind'] } : {}),
+        };
+    }
+    return receipt;
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@evomap/evolver-adapter-public",
+  "version": "2.0.0-beta.0",
+  "private": false,
+  "type": "module",
+  "description": "公版 hub 适配器 (积分/治理)",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@evomap/atp-sdk": "^0.1.0",
+    "@evomap/evolver-core": "2.0.0-beta.0",
+    "undici": "^6.27.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "v2-beta"
+  },
+  "files": [
+    "dist/",
+    "README.md",
+    "package.json"
+  ]
+}