@entmesh/sdk-miniapp 0.2.0 → 0.2.1

package/README.md

@@ -2,12 +2,30 @@
 
 One privacy-first SDK for WeChat, Alipay, and Douyin mini programs. Import the runtime-specific entry, initialize before `App` and `Page` registration, grant analytics consent, and register the Collector domain in the platform console.
 
+The first public npm release is [@entmesh/sdk-miniapp@0.2.0](https://www.npmjs.com/package/@entmesh/sdk-miniapp/v/0.2.0), published on 2026-10-31. Its source is tagged [v0.2.0](https://cnb.cool/mliev/entmesh/sdk-miniapp/-/tree/v0.2.0).
+
+## Installation and platform entries
+
 Install from the public npm registry:
 
 ```sh
 npm install @entmesh/sdk-miniapp --registry=https://registry.npmjs.org/
 ```
 
+To reproduce the first release, install `@entmesh/sdk-miniapp@0.2.0` explicitly.
+Use the entry for your platform:
+
+| Platform | Import |
+| --- | --- |
+| WeChat | `@entmesh/sdk-miniapp/wechat` |
+| Alipay | `@entmesh/sdk-miniapp/alipay` |
+| Douyin | `@entmesh/sdk-miniapp/douyin` |
+
+Each entry exports `createClient` and the platform-independent option types.
+Import a platform subpath; the package root is not an exported entry.
+
+## Quick start
+
 ```ts
 import { createClient } from '@entmesh/sdk-miniapp/wechat'
 
@@ -25,15 +43,42 @@ await entmesh.track('order_created', { order_id: 'order-1' })
 
 The SDK uses platform secure-random, storage, and request APIs. It never falls back to `Math.random`, never reads host-device advertising identifiers, and never sends plaintext batches.
 
-Use `@entmesh/sdk-miniapp/alipay` for Alipay or `@entmesh/sdk-miniapp/douyin` for Douyin. Each entry exports `createClient` and the platform-independent option types.
+## Page context and visible time (0.2.1)
+
+With `autocapture` enabled, the SDK tracks application startup/foreground/background
+and each page's show/hide/unload lifecycle. Initialize before `App()` and `Page()`
+registration. Page paths are recorded in `context.page.path`; manual `track()` and
+`identify()` events inherit the page that was current when the call occurred.
+`page(route, { title: 'Order details' })` also supplies `context.page.title`.
+
+Page visibility events carry `properties.visible_ms`. Each visible interval is
+counted once, even when page hiding, application backgrounding and unloading all
+occur. Background time is excluded. A page exit following an already-recorded hide
+does not repeat the duration. Startup is recorded once per SDK instance, and the
+last visibility/background events enter the persistent queue before flushing.
+
+If the user grants consent while a page is already visible, the SDK records that
+page once and begins timing at consent. Activity before consent is not replayed.
+Repeated grants and duplicate show callbacks do not create additional views.
+Clicks, page-internal tab changes, scrolling and element impressions still require
+manual events; this release does not automatically collect them.
+
+Upgrade the business mini program to `@entmesh/sdk-miniapp@0.2.1` to collect visible
+time. Earlier events retain their existing route, but no measured duration; reports
+display **未采集** rather than estimating time from neighboring timestamps.
+
+Examples written before the public release used `@entmesh/miniapp-sdk`. Update
+both the dependency name and imports to `@entmesh/sdk-miniapp`; the platform
+suffixes and client API remain the same. The public package is distributed through
+npmjs.org, so a CNB npm registry configuration is not required.
 
 ## User properties (Proto 4.30)
 
 ```ts
-await client.identify('user-123', { plan: 'trial' })
-await client.setUserProperties({ plan: 'pro' })
-await client.unsetUserProperties(['legacy_tier'])
-await client.flush()
+await entmesh.identify('user-123', { plan: 'trial' })
+await entmesh.setUserProperties({ plan: 'pro' })
+await entmesh.unsetUserProperties(['legacy_tier'])
+await entmesh.flush()
 ```
 
 Enable the profile platform and organization entitlement before using these APIs. Attribute mutations use a dedicated transport and do not create behavior events or sessions. Set merges specified top-level fields; objects and arrays replace the previous whole value. Unset removes a key; explicit null remains an empty value. Existing identify properties also populate the profile; ordinary event properties do not.
@@ -56,8 +101,9 @@ npm run check:package
 `package.json` is the version source. Both `npm version` and `npm run build`
 synchronize `VERSION` and the generated runtime constant in `src/version.ts`.
 
-Branch pushes and pull requests only validate the SDK. Pushing a stable `vX.Y.Z`
-tag runs the release pipeline, sets the package version before testing and building,
+Pushes and pull requests targeting `main` or `develop` only validate the SDK.
+Pushing a stable `vX.Y.Z` tag runs the release pipeline, sets the package version
+before testing and building,
 and publishes `@entmesh/sdk-miniapp` publicly to npmjs.org. The first release is
 `v0.2.0`; preparing an already-matching package version is supported. Publishing a
 version that already exists on npm fails instead of silently skipping it.
@@ -77,3 +123,65 @@ Only the publish step imports it. `npm run publish:npm` checks the package, uses
 temporary npm configuration containing an environment-variable reference, and
 removes that configuration on exit. The token is never written to the SDK source
 or printed by the publishing script.
+
+### Publish a new version
+
+Run from a clean `main` checkout. The example uses `0.2.2`; replace it with the
+next unused stable version.
+
+```sh
+release_version=0.2.2
+npm ci
+npm version "$release_version" --no-git-tag-version --allow-same-version
+npm test
+npm run lint
+npm run build
+npm run check:package
+git add package.json package-lock.json VERSION src/version.ts
+git commit -m "chore: prepare sdk-miniapp $release_version"
+git push origin main
+```
+
+After the `main` quality pipeline succeeds, publish its version tag:
+
+```sh
+git tag -a "v$release_version" -m "Release @entmesh/sdk-miniapp $release_version"
+git push origin "refs/tags/v$release_version"
+```
+
+The tag pipeline validates the tag, installs dependencies, synchronizes versions,
+runs tests and type checking, builds, checks package contents, and publishes with
+public access. Package checks cover the three platform entries, declarations,
+runtime version, and the files included in the npm package.
+
+### Verify publication and troubleshoot
+
+Check the release pipeline and then verify the public registry:
+
+```sh
+npm view "@entmesh/sdk-miniapp@$release_version" version dist.integrity --registry=https://registry.npmjs.org/ --prefer-online
+```
+
+In a separate consumer project, install the published version and check its imports:
+
+```sh
+npm install "@entmesh/sdk-miniapp@$release_version" --registry=https://registry.npmjs.org/
+node --input-type=module <<'JS'
+for (const platform of ['wechat', 'alipay', 'douyin']) {
+  const sdk = await import('@entmesh/sdk-miniapp/' + platform)
+  if (typeof sdk.createClient !== 'function') throw new Error(platform)
+  console.log(platform + ': import OK')
+}
+JS
+```
+
+- If npm reports that the package is being processed, publication has been accepted
+  but registry queries or installs may temporarily return 404. Wait and repeat the
+  registry and consumer checks before declaring the version available.
+- A missing `NPM_TOKEN` stops publication. Check the secret file URL, its
+  `allow_slugs`, and the token's scope permissions and expiration.
+- An already-published version cannot be overwritten. Use a new version and tag;
+  do not move the existing release tag.
+- HPKE tests must read the committed `test/fixtures/hpke-browser-v1.json`. Do not
+  restore a dependency on a sibling `proto` checkout. The cross-repository E2E
+  contract test checks this copy against the protocol source.

package/dist/core.d.ts

@@ -10,7 +10,10 @@ export declare class MiniProgramClient {
     private timer?;
     private sending?;
     private key?;
-    private appStartSent;
+    private readonly ready;
+    private recording;
+    private consentGeneration;
+    private readonly lifecycle;
     constructor(adapter: RuntimeAdapter, options: MiniProgramOptions);
     private initialize;
     track(eventName: string, properties?: Properties): Promise<void>;
@@ -25,6 +28,7 @@ export declare class MiniProgramClient {
     refreshDeviceIdentifiers(): Promise<void>;
     flush(): Promise<void>;
     shutdown(): Promise<void>;
+    private record;
     private capture;
     private deliver;
     private discovery;

package/dist/core.js

@@ -1,24 +1,30 @@
 import { decodeBase64url, encryptedEnvelope, sealHPKE, utf8 } from './hpke.js';
 import { SDK_VERSION } from './version.js';
+import { LifecycleTracker } from './lifecycle.js';
 const ANONYMOUS_KEY = 'entmesh_anonymous_id';
 const SESSION_KEY = 'entmesh_session';
 const QUEUE_KEY = 'entmesh_event_queue';
 const SESSION_TIMEOUT = 30 * 60 * 1000;
 const QUEUE_LIMIT = 500;
+const lifecycleTrackers = new WeakMap();
 export class MiniProgramClient {
     constructor(adapter, options) {
         this.adapter = adapter;
         this.options = options;
         this.anonymous = '';
         this.session = { id: '', lastActivity: 0 };
-        this.appStartSent = false;
+        this.recording = Promise.resolve();
+        this.consentGeneration = 0;
         if (!options.clientKey.startsWith('ck_'))
             throw new Error('clientKey must be a ck_ key');
         if (!/^https:\/\//.test(options.endpoint) && !/^http:\/\/localhost(?::\d+)?$/.test(options.endpoint))
             throw new Error('endpoint must use HTTPS');
         this.consentState = options.consent ?? 'pending';
         this.queue = this.readQueue();
-        void this.initialize();
+        this.lifecycle = new LifecycleTracker(this.consentState === 'grant', (type, name, properties, page) => this.capture(type, name, properties, page), () => this.flush());
+        lifecycleTrackers.set(this, this.lifecycle);
+        this.ready = this.initialize();
+        void this.ready.catch(() => undefined);
     }
     async initialize() {
         this.anonymous = String(this.adapter.getStorage(ANONYMOUS_KEY) || '') || await this.id();
@@ -30,7 +36,10 @@ export class MiniProgramClient {
         this.timer = setInterval(() => { void this.flush(); }, this.options.flushIntervalMs ?? 5000);
     }
     async track(eventName, properties = {}) { await this.capture('track', eventName, properties); }
-    async page(route, properties = {}) { await this.capture('page', '$page_view', { route, ...properties }); }
+    async page(route, properties = {}) {
+        const page = this.lifecycle.setPage(route, properties);
+        await this.capture('page', '$page_view', { ...properties, route }, page);
+    }
     async screen(route, properties = {}) { await this.page(route, properties); }
     async identify(userID, properties = {}) {
         const value = userID.trim();
@@ -45,24 +54,40 @@ export class MiniProgramClient {
         if (this.consentState !== 'grant')
             return;
         const user = this.user;
+        const generation = this.consentGeneration;
         if (!user)
             throw new Error('identify a user before updating properties');
-        if (this.queue.length >= QUEUE_LIMIT)
-            throw new Error('profile queue is full');
-        this.queue.push({ mutation_id: await this.id(), occurred_at: new Date().toISOString(), subject: { kind: 'user', id: user }, operation, ...(properties ? { properties: JSON.parse(JSON.stringify(properties)) } : {}), ...(unset ? { unset: [...unset] } : {}) });
-        this.persistQueue();
+        const occurredAt = new Date().toISOString();
+        const values = properties ? JSON.parse(JSON.stringify(properties)) : undefined;
+        const keys = unset ? [...unset] : undefined;
+        await this.record(async () => {
+            if (generation !== this.consentGeneration || this.consentState !== 'grant')
+                return;
+            if (this.queue.length >= QUEUE_LIMIT)
+                throw new Error('profile queue is full');
+            const mutationID = await this.id();
+            if (generation !== this.consentGeneration || this.consentState !== 'grant')
+                return;
+            this.queue.push({ mutation_id: mutationID, occurred_at: occurredAt, subject: { kind: 'user', id: user }, operation, ...(values ? { properties: values } : {}), ...(keys ? { unset: keys } : {}) });
+            this.persistQueue();
+        });
         if (this.queue.length >= (this.options.batchSize ?? 20))
             await this.flush();
     }
     async reset() {
         this.user = undefined;
+        await this.ready;
+        await this.recording;
         this.anonymous = await this.id();
         this.session = { id: await this.id(), lastActivity: Date.now() };
         this.adapter.setStorage(ANONYMOUS_KEY, this.anonymous);
         this.adapter.setStorage(SESSION_KEY, this.session);
     }
     async consent(state) {
+        if (this.consentState !== state)
+            this.consentGeneration++;
         this.consentState = state;
+        const lifecycle = this.lifecycle.setConsent(state === 'grant');
         if (state === 'deny' || state === 'revoke') {
             this.queue = [];
             this.persistQueue();
@@ -74,19 +99,18 @@ export class MiniProgramClient {
             return;
         }
         if (state === 'grant') {
-            if (!this.appStartSent) {
-                this.appStartSent = true;
-                await this.capture('track', '$app_start', {});
-            }
+            await lifecycle;
             await this.flush();
         }
     }
     async refreshDeviceIdentifiers() { }
     async flush() {
+        await this.ready;
+        await this.recording;
+        while (this.sending)
+            await this.sending;
         if (this.consentState !== 'grant' || this.queue.length === 0)
             return;
-        if (this.sending)
-            return this.sending;
         this.sending = (async () => { let remaining = this.queue.length; while (remaining > 0 && this.consentState === 'grant') {
             const before = this.queue.length;
             await this.deliver();
@@ -97,29 +121,45 @@ export class MiniProgramClient {
         } })().finally(() => { this.sending = undefined; });
         return this.sending;
     }
-    async shutdown() { if (this.timer)
+    async shutdown() { await this.ready; if (this.timer)
         clearInterval(this.timer); await this.flush(); }
-    async capture(type, eventName, properties) {
+    record(action) {
+        const pending = this.recording.then(() => this.ready).then(action);
+        this.recording = pending.catch(() => undefined);
+        return pending;
+    }
+    async capture(type, eventName, properties, page = this.lifecycle.pageContext()) {
         if (this.consentState !== 'grant')
             return;
         if (!/^[$A-Za-z][A-Za-z0-9_.-]{0,127}$/.test(eventName))
             throw new Error('event name is invalid');
         const now = Date.now();
-        if (!this.session.id || now - this.session.lastActivity >= SESSION_TIMEOUT)
-            this.session = { id: await this.id(), lastActivity: now };
-        this.session.lastActivity = now;
-        this.adapter.setStorage(SESSION_KEY, this.session);
-        const event = {
-            message_id: await this.id(), type, event_name: eventName, occurred_at: new Date(now).toISOString(),
-            anonymous_id: this.anonymous || await this.id(), session_id: this.session.id, properties,
-            context: { sdk: { name: 'entmesh-miniapp', version: SDK_VERSION }, device: this.adapter.systemContext() },
-        };
-        if (this.user)
-            event.user_id = this.user;
-        if (this.queue.length >= QUEUE_LIMIT)
-            this.queue.shift();
-        this.queue.push(event);
-        this.persistQueue();
+        const generation = this.consentGeneration;
+        const user = this.user;
+        const snapshot = { ...page };
+        const endsVisibleInterval = eventName === '$visibility' || eventName === '$page_exit';
+        const values = JSON.parse(JSON.stringify(properties));
+        await this.record(async () => {
+            if (generation !== this.consentGeneration || this.consentState !== 'grant')
+                return;
+            if (!this.session.id || (!endsVisibleInterval && now - this.session.lastActivity >= SESSION_TIMEOUT))
+                this.session = { id: await this.id(), lastActivity: now };
+            this.session.lastActivity = now;
+            this.adapter.setStorage(SESSION_KEY, this.session);
+            const event = {
+                message_id: await this.id(), type, event_name: eventName, occurred_at: new Date(now).toISOString(),
+                anonymous_id: this.anonymous, session_id: this.session.id, properties: values,
+                context: { sdk: { name: 'entmesh-miniapp', version: SDK_VERSION }, device: this.adapter.systemContext(), ...(snapshot.path ? { page: snapshot } : {}) },
+            };
+            if (user)
+                event.user_id = user;
+            if (generation !== this.consentGeneration || this.consentState !== 'grant')
+                return;
+            if (this.queue.length >= QUEUE_LIMIT)
+                this.queue.shift();
+            this.queue.push(event);
+            this.persistQueue();
+        });
         if (this.queue.length >= (this.options.batchSize ?? 20))
             await this.flush();
     }
@@ -143,7 +183,7 @@ export class MiniProgramClient {
             }
             if (response.statusCode < 200 || response.statusCode >= 300)
                 return;
-            this.queue.splice(0, events.length);
+            this.queue = this.queue.filter(event => !events.includes(event));
             this.persistQueue();
         }
         catch { /* Retain the persistent queue for the next bounded flush attempt. */ }
@@ -165,34 +205,5 @@ export class MiniProgramClient {
     async id() { return Array.from(await this.adapter.randomBytes(16), (value) => value.toString(16).padStart(2, '0')).join(''); }
 }
 export function installLifecycle(client) {
-    const root = globalThis;
-    const wrap = (name) => {
-        const original = root[name];
-        if (typeof original !== 'function' || original.__entmesh)
-            return;
-        const wrapped = (options) => {
-            const next = { ...options };
-            const handlers = name === 'App'
-                ? { onLaunch: '$app_start', onShow: '$app_foreground', onHide: '$app_background' }
-                : { onShow: '$page_view', onHide: '$visibility', onUnload: '$page_exit' };
-            for (const [handler, eventName] of Object.entries(handlers)) {
-                const existing = next[handler];
-                next[handler] = function (...args) {
-                    const route = String(this.route || this.__route__ || '');
-                    if (eventName === '$page_view')
-                        void client.page(route);
-                    else
-                        void client.track(eventName, route ? { route } : {});
-                    if (eventName === '$app_background')
-                        void client.flush();
-                    return typeof existing === 'function' ? existing.apply(this, args) : undefined;
-                };
-            }
-            return original(next);
-        };
-        wrapped.__entmesh = true;
-        root[name] = wrapped;
-    };
-    wrap('App');
-    wrap('Page');
+    lifecycleTrackers.get(client)?.install();
 }

package/dist/lifecycle.d.ts

@@ -0,0 +1,29 @@
+import type { Properties } from './types.js';
+export interface PageContext {
+    path: string;
+    title?: string;
+}
+type Emit = (type: 'page' | 'track', name: string, properties: Properties, page: PageContext) => Promise<void>;
+/** Owns visible intervals; App and Page callbacks can close the same interval safely. */
+export declare class LifecycleTracker {
+    private granted;
+    private readonly emit;
+    private readonly flush;
+    private readonly pages;
+    private active?;
+    private context;
+    private foreground?;
+    private started;
+    constructor(granted: boolean, emit: Emit, flush: () => Promise<void>);
+    pageContext(): PageContext;
+    setPage(path: string, properties?: Properties): PageContext;
+    setConsent(granted: boolean): Promise<void>;
+    private start;
+    private begin;
+    private finish;
+    private app;
+    private page;
+    private route;
+    install(): void;
+}
+export {};

package/dist/lifecycle.js

@@ -0,0 +1,147 @@
+/** Owns visible intervals; App and Page callbacks can close the same interval safely. */
+export class LifecycleTracker {
+    constructor(granted, emit, flush) {
+        this.granted = granted;
+        this.emit = emit;
+        this.flush = flush;
+        this.pages = new WeakMap();
+        this.context = { path: '' };
+        this.started = false;
+    }
+    pageContext() { return { ...this.context }; }
+    setPage(path, properties = {}) {
+        const title = typeof properties.title === 'string' ? properties.title : undefined;
+        this.context = { path, ...(title ? { title } : {}) };
+        if (this.active?.page.path === path)
+            this.active.page = this.pageContext();
+        return this.pageContext();
+    }
+    setConsent(granted) {
+        const changed = this.granted !== granted;
+        this.granted = granted;
+        if (!granted) {
+            if (this.active)
+                this.active.since = undefined;
+            return Promise.resolve();
+        }
+        const start = this.start();
+        const page = changed && this.active ? this.begin(this.active) : Promise.resolve();
+        return Promise.all([start, page]).then(() => undefined);
+    }
+    start() {
+        if (!this.granted || this.started)
+            return Promise.resolve();
+        this.started = true;
+        return this.emit('track', '$app_start', {}, this.pageContext());
+    }
+    begin(state) {
+        if (!this.granted || this.foreground === false || !state.shown || state.since !== undefined)
+            return Promise.resolve();
+        state.since = Date.now();
+        return this.emit('page', '$page_view', { route: state.page.path }, { ...state.page });
+    }
+    finish(state, name) {
+        if (!state)
+            return Promise.resolve();
+        const since = state.since;
+        state.since = undefined;
+        if (!this.granted || (since === undefined && name === '$visibility'))
+            return Promise.resolve();
+        const properties = { route: state.page.path };
+        if (since !== undefined)
+            properties.visible_ms = Math.max(0, Date.now() - since);
+        return this.emit('track', name, properties, { ...state.page });
+    }
+    app(handler, options) {
+        const path = options && typeof options === 'object' && 'path' in options && typeof options.path === 'string' ? options.path : '';
+        if (path && !this.active)
+            this.setPage(path);
+        if (handler === 'onLaunch')
+            return this.start();
+        if (handler === 'onShow') {
+            if (this.foreground === true)
+                return Promise.resolve();
+            this.foreground = true;
+            const foreground = this.emit('track', '$app_foreground', {}, this.pageContext());
+            const page = this.active && (!path || path === this.active.page.path) ? this.begin(this.active) : Promise.resolve();
+            return Promise.all([foreground, page]).then(() => undefined);
+        }
+        if (this.foreground === false)
+            return Promise.resolve();
+        this.foreground = false;
+        const visible = this.finish(this.active, '$visibility');
+        const background = this.emit('track', '$app_background', {}, this.pageContext());
+        return Promise.all([visible, background]).then(() => this.flush());
+    }
+    page(handler, owner) {
+        let state = this.pages.get(owner);
+        if (handler === 'onShow') {
+            const path = this.route(owner);
+            if (!state) {
+                state = { page: { path }, shown: false };
+                this.pages.set(owner, state);
+            }
+            const previous = this.active !== state ? this.finish(this.active, '$visibility') : Promise.resolve();
+            if (this.active && this.active !== state)
+                this.active.shown = false;
+            state.page = { ...state.page, path };
+            state.shown = true;
+            this.active = state;
+            this.context = { ...state.page };
+            return Promise.all([previous, this.begin(state)]).then(() => undefined);
+        }
+        if (!state)
+            return Promise.resolve();
+        state.shown = false;
+        const result = this.finish(state, handler === 'onUnload' ? '$page_exit' : '$visibility');
+        if (handler === 'onUnload') {
+            this.pages.delete(owner);
+            if (this.active === state)
+                this.active = undefined;
+        }
+        return result;
+    }
+    route(owner) {
+        const route = owner.route || owner.__route__;
+        if (typeof route === 'string')
+            return route;
+        const getPages = globalThis.getCurrentPages;
+        if (typeof getPages === 'function') {
+            try {
+                const pages = getPages();
+                const current = pages[pages.length - 1];
+                return String(current?.route || current?.__route__ || '');
+            }
+            catch { /* Some runtimes expose no page stack during registration. */ }
+        }
+        return '';
+    }
+    install() {
+        const root = globalThis;
+        for (const name of ['App', 'Page']) {
+            const original = root[name];
+            if (typeof original !== 'function' || original.__entmesh)
+                continue;
+            const tracker = this;
+            const wrapped = (options) => {
+                const next = { ...options };
+                const handlers = name === 'App' ? ['onLaunch', 'onShow', 'onHide'] : ['onShow', 'onHide', 'onUnload'];
+                for (const handler of handlers) {
+                    const existing = next[handler];
+                    next[handler] = function (...args) {
+                        // Analytics errors must not replace a business callback's return value or exception.
+                        try {
+                            const pending = name === 'App' ? tracker.app(handler, args[0]) : tracker.page(handler, this);
+                            void pending.catch(() => undefined);
+                        }
+                        catch { /* The application's lifecycle still runs if collection fails. */ }
+                        return typeof existing === 'function' ? existing.apply(this, args) : undefined;
+                    };
+                }
+                return original(next);
+            };
+            wrapped.__entmesh = true;
+            root[name] = wrapped;
+        }
+    }
+}

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const SDK_VERSION = "0.2.0";
+export declare const SDK_VERSION = "0.2.1";

package/dist/version.js

@@ -1,2 +1,2 @@
 // Generated from package.json by scripts/sync-version.mjs.
-export const SDK_VERSION = '0.2.0';
+export const SDK_VERSION = '0.2.1';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@entmesh/sdk-miniapp",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",