@deepseek-ai/dsh-client-store 0.1.2-alpha.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DeepSeek
+
+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.i18n.yaml

@@ -0,0 +1,6 @@
+# Bilingual-pair consistency record (docs/i18n/README.md): the git blob hash of each
+# side as of the last confirmed-consistent state. Both languages carry equal authority;
+# after editing either side, bring the other along and re-record with:
+#   pnpm run verify-translation-pairing --write packages/client/store/README.md
+README.md: 49990551a47e81cdeeeeee0daa56b6fadb956fe6
+README.zh.md: 97c29b9f776c06c5b8eddd382d1d3dc58e29a8d5

package/README.md

@@ -0,0 +1,45 @@
+---
+description: "Observable browser state stores with explicit snapshots, subscriptions, and lifecycle ownership."
+kind: "package-library"
+---
+# @deepseek-ai/dsh-client-store
+
+English | [中文](README.zh.md)
+
+## Summary
+
+React-free observable and snapshot-store primitives shared by Client controllers and renderer adapters. The package owns synchronous and animation-frame publication, Immer-backed updates, shallow equality, and optional browser persistence; React hook construction remains in `@deepseek-ai/dsh-client-ui-renderer`. Use it when Client state must publish stable snapshots without depending on React.
+
+## Table of Contents
+
+- [Model Experience](#model-experience)
+- [Known Limitations and Deferred Work](#known-limitations-and-deferred-work)
+- [Dev Note](#dev-note)
+
+-----
+
+<a id="model-experience"></a>
+## Model Experience
+
+None, as this package provides browser-side state primitives and registers nothing model-facing.
+
+#### KV Cache effect
+
+None; the stores neither assemble nor send model requests.
+
+## Known Limitations and Deferred Work
+
+<a id="known-limitations-and-deferred-work"></a>
+
+- **Persistence is browser-local** — persisted stores use JSON in `localStorage`; non-browser runtimes disable persistence, and the package provides no cross-device synchronization.
+
+
+<a id="dev-note"></a>
+### Dev Note
+
+<details>
+<summary>Working context for maintainers — click to expand</summary>
+
+None.
+
+</details>

package/README.zh.md

@@ -0,0 +1,45 @@
+---
+description: "具有显式快照、订阅与生命周期所有权的浏览器可观察状态 store。"
+kind: "package-library"
+---
+# @deepseek-ai/dsh-client-store
+
+[English](README.md) | 中文
+
+## 概述
+
+供 Client controller 与 renderer adapter 共用的不依赖 React 的 observable 和 snapshot-store 基础设施。本包负责同步与 animation-frame 发布、基于 Immer 的更新、浅比较和可选的浏览器持久化；React hook 的构造仍属于 `@deepseek-ai/dsh-client-ui-renderer`。当 Client 状态必须在不依赖 React 的情况下发布稳定 snapshot 时，请使用它。
+
+## 目录
+
+- [模型体验](#model-experience)
+- [已知限制与暂缓事项](#known-limitations-and-deferred-work)
+- [开发备注](#dev-note)
+
+-----
+
+<a id="model-experience"></a>
+## 模型体验
+
+无，因为本包提供浏览器侧状态基础设施，不注册任何面向模型的内容。
+
+#### KV Cache 影响
+
+无；这些 store 既不组装也不发送模型请求。
+
+## 已知限制与暂缓事项
+
+<a id="known-limitations-and-deferred-work"></a>
+
+- **持久化仅限浏览器本地**——持久化 store 使用 `localStorage` 中的 JSON；非浏览器运行时会禁用持久化，本包也不提供跨设备同步。
+
+
+<a id="dev-note"></a>
+### 开发备注
+
+<details>
+<summary>维护者工作上下文——点击展开</summary>
+
+无。
+
+</details>

package/lib/index.js

@@ -0,0 +1,180 @@
+import { createStore } from "zustand/vanilla";
+import { subscribeWithSelector } from "zustand/middleware";
+import { shallow } from "zustand/shallow";
+import { freeze, produce } from "immer";
+//#region lib/types/index.js
+/**
+* React-free snapshot store engine (zustand vanilla + immer + subscribeWithSelector +
+* rafFlush middleware + opt-in persist + dev freeze) plus the declarative
+* shell over it: {@link defineStore} bakes an init/persist/actions literal
+* into a {@link StoreHandle}, the registration-side store seat of slot
+* terminals. Engine products are bare observables — subscribe/getSnapshot/
+* update/set, NO selector hook. Hook synthesis is ui-renderer's (the one
+* uSES bridge, cached per source at the binding site).
+*/
+/**
+* Notify an observer set without allowing one callback to starve the rest.
+* @param listeners - current observer callbacks; copied before dispatch.
+* @param label - diagnostic owner prefix.
+* @param args - callback arguments.
+*/
+function notifySubscribers(listeners, label, ...args) {
+	for (const listener of [...listeners]) try {
+		listener(...args);
+	} catch (error) {
+		console.error(`${label} subscriber failed:`, error);
+	}
+}
+/**
+* Shallow equality for selector slices (zustand/shallow semantics; travels
+* with the engine so hook consumers need no zustand dependency).
+* @param a - left value.
+* @param b - right value.
+* @returns whether the values are shallowly equal.
+*/
+function shallowEqual(a, b) {
+	return shallow(a, b);
+}
+/** Batches subscriber notification into one flush per animation frame. */
+function rafBatch(notify) {
+	const schedule = typeof requestAnimationFrame === "function" ? (fn) => {
+		requestAnimationFrame(() => {
+			fn();
+		});
+	} : (fn) => {
+		queueMicrotask(fn);
+	};
+	let scheduled = false;
+	return () => {
+		if (scheduled) return;
+		scheduled = true;
+		schedule(() => {
+			scheduled = false;
+			notify();
+		});
+	};
+}
+/**
+* Create a snapshot store.
+*
+* Flush default is 'sync' (controlled inputs need same-tick echo); frame-driven
+* stores opt into 'raf', where a frame's worth of updates coalesces into one
+* notification. Known raf-mode tradeoff: a component mounting mid-frame reads
+* fresh state while existing subscribers hear it next flush — transient
+* frame-level skew, same nature as the object layer's microtask batching.
+*
+* @param init - initial state.
+* @param opts - flush mode and opt-in persistence (localStorage, keyed by name).
+* @returns the store.
+*/
+function createSnapshotStore(init, opts) {
+	const withSelector = subscribeWithSelector(() => init);
+	const api = createStore()(withSelector);
+	if (opts?.persist) attachPersistence(api, opts.persist.name);
+	let subscribe = (fn) => api.subscribe(() => {
+		notifySubscribers([fn], "[client-store]");
+	});
+	if (opts?.flush === "raf") {
+		const listeners = /* @__PURE__ */ new Set();
+		const flush = rafBatch(() => {
+			notifySubscribers(listeners, "[client-store]");
+		});
+		api.subscribe(flush);
+		subscribe = (fn) => {
+			listeners.add(fn);
+			return () => {
+				listeners.delete(fn);
+			};
+		};
+	}
+	return {
+		getSnapshot: () => api.getState(),
+		subscribe: (fn) => subscribe(fn),
+		update: (mutator) => {
+			api.setState(produce(api.getState(), (draft) => {
+				mutator(draft);
+			}), true);
+		},
+		set: (next) => {
+			api.setState(devFreeze(next), true);
+		}
+	};
+}
+/**
+* Whole-value JSON persistence to localStorage. Hand-rolled instead of the
+* zustand persist middleware: its write path spreads state into an object
+* (`partialize({ ...get() })`), exploding primitive state (a persisted string
+* draft becomes {0:'h',1:'e',...}) — not fixable via merge/deserialize options
+* because the corruption happens before serialization. Storage failures
+* (quota, private mode) only disable persistence, never break the store.
+*/
+function attachPersistence(api, name) {
+	if (typeof localStorage === "undefined") return;
+	try {
+		const raw = localStorage.getItem(name);
+		if (raw !== null) api.setState(devFreeze(JSON.parse(raw)), true);
+	} catch (error) {
+		console.error(`snapshot store '${name}' rehydration failed:`, error);
+	}
+	api.subscribe((state) => {
+		try {
+			localStorage.setItem(name, JSON.stringify(state));
+		} catch (error) {
+			console.error(`snapshot store '${name}' persistence failed:`, error);
+		}
+	});
+}
+/** Deep-freeze draftable wholesale-set state outside production: set() bypasses immer's freeze. */
+function devFreeze(value) {
+	return freeze(value, true);
+}
+/**
+* Declare a store: initial state, optional persistence, and the full write
+* set as pure draft mutators. The returned handle is the registration
+* currency of the store seat — its identity keys instance sharing. Satisfies
+* ui-slots' DefineStore contract (the handle/instance are the engine-extended
+* subtypes).
+*
+* The `A & ActionsDecl<T>` actions position is load-bearing: T resolves from
+* `init` in the first inference round, and the intersection then contextually
+* types each mutator's draft parameter (context-sensitive functions defer),
+* so call sites write `(d, x: X) => { ... }` with no draft annotation. If a
+* future TS version breaks this single-literal inference, the design's
+* documented fallback is currying (`defineStore(init).actions({...})`).
+* @param decl - init lambda (fresh state per instance), optional persist key, actions table.
+* @returns the store handle.
+*/
+function defineStore(decl) {
+	return {
+		spec: decl,
+		create(scopeKey) {
+			const persistKey = decl.persist === void 0 ? void 0 : scopeKey === void 0 ? decl.persist : `${decl.persist}.${scopeKey}`;
+			const store = createSnapshotStore(decl.init(), persistKey !== void 0 ? { persist: { name: persistKey } } : void 0);
+			const actions = {};
+			for (const key of Object.keys(decl.actions)) {
+				const mutate = decl.actions[key];
+				actions[key] = (...params) => {
+					store.update((draft) => {
+						mutate(draft, ...params);
+					});
+				};
+			}
+			return {
+				actions,
+				getSnapshot: () => store.getSnapshot(),
+				subscribe: (fn) => store.subscribe(fn),
+				store,
+				clearPersisted: () => {
+					if (persistKey === void 0 || typeof localStorage === "undefined") return;
+					try {
+						localStorage.removeItem(persistKey);
+					} catch {}
+				}
+			};
+		}
+	};
+}
+//#endregion
+export { createSnapshotStore, defineStore, notifySubscribers, shallowEqual };
+
+//# sourceMappingURL=index.js.map

package/lib/invariant.js

@@ -0,0 +1,25 @@
+//#region lib/types/invariant.js
+/**
+* Package-owned invariant companion for `@deepseek-ai/dsh-client-store`.
+* @module @deepseek-ai/dsh-client-store/invariant
+*/
+const PACKAGE_NAME = "@deepseek-ai/dsh-client-store";
+/** Cordis companion plugin name. */
+const name = "client-store-invariant";
+/** Service required before the companion can reserve package ownership. */
+const inject = ["invariants"];
+/**
+* No runtime invariant: the package exports a library engine and creates no
+* process-global state; each store instance is covered by its owning tests.
+*/
+const install = () => {};
+/**
+* Register this package's invariant companion.
+* @param ctx - Cordis context carrying the invariant service.
+* @returns the installed registration's disposer after setup succeeds.
+*/
+const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+//#endregion
+export { apply, inject, name };
+
+//# sourceMappingURL=invariant.js.map

package/lib/types/contract.d.ts

@@ -0,0 +1,122 @@
+/** Framework-neutral snapshot and store contracts. */
+/** Minimal observable snapshot source shared by controllers, stores, and render adapters. */
+export interface ObservableSnapshot<T> {
+    /** Read the cached snapshot reference. */
+    getSnapshot(): T;
+    /**
+     * Subscribe to snapshot invalidation.
+     * @param fn - invalidation callback.
+     * @returns unsubscribe function.
+     */
+    subscribe(fn: () => void): () => void;
+}
+/**
+ * Typed selector hook over a snapshot source. Canonical shape for the whole
+ * slot system (ui-renderer's engine hook is structurally identical; the
+ * framework is the only party that ever constructs one).
+ */
+export type SnapshotSelectorHook<T> = <S>(sel: (s: T) => S, eq?: (a: S, b: S) => boolean) => S;
+/**
+ * Selector hook over a source that follows the current session. The hook is
+ * always present, while its selected value is absent whenever no session is
+ * current. This keeps hook call sites stable across no-session/session
+ * transitions without pretending that a session snapshot exists.
+ */
+export type MaybeSnapshotSelectorHook<T> = <S>(sel: (s: T) => S, eq?: (a: S, b: S) => boolean) => S | undefined;
+/**
+ * Action declaration table: pure immer-draft transforms over the store state,
+ * declared as the store's complete write set (the audit face — components can
+ * only write through these).
+ */
+export type ActionsDecl<T> = Record<string, (draft: T, ...params: any[]) => void>;
+/**
+ * Draft-stripped callback form of an actions table: what components
+ * (`props.actions`) and inject factories receive — the framework bakes the
+ * draft parameter away by binding each action to the resolved instance.
+ */
+export type BakedActions<T, A extends ActionsDecl<T>> = {
+    [K in keyof A]: A[K] extends (draft: T, ...params: infer P) => void ? (...params: P) => void : never;
+};
+/**
+ * Store declaration spec: initial-state factory (a lambda so every instance
+ * gets a fresh state), optional persistence key (mechanical, framework-run),
+ * and the actions write set.
+ */
+export interface StoreSpec<T, A extends ActionsDecl<T>> {
+    init: () => T;
+    persist?: string;
+    actions: A;
+}
+/**
+ * Live engine instance: the create() product consumed by the render machinery
+ * and by tests. A bare snapshot source plus the baked write set — no React
+ * hook rides the engine product (the engine lives in this React-free package);
+ * the render machinery binds the `useStore` hook from this source on its own
+ * side, cached per instance. Production components and render paths never
+ * call create() themselves — instance lifecycle is the framework's.
+ */
+export interface StoreInstance<T, A extends ActionsDecl<T>> {
+    readonly actions: BakedActions<T, A>;
+    getSnapshot(): T;
+    /**
+     * Subscribe to state changes (uSES subscribe side).
+     * @param fn - change callback.
+     * @returns unsubscribe.
+     */
+    subscribe(fn: () => void): () => void;
+    /**
+     * Drop this instance's persisted value (no-op for non-persist specs). The
+     * framework calls it when the owning scope dies for good — a pruned session
+     * must not leave orphaned storage keys behind.
+     */
+    clearPersisted(): void;
+}
+/**
+ * Store handle: spec + state/actions types + shared identity + instance
+ * factory in one value. Handles are constructed in apply world (shared across
+ * registrations of one plugin) or by the framework from a registrant's
+ * factory (exclusive). Never export a handle at module level — module-cache
+ * identity is a disguised singleton across plugin reloads.
+ */
+export interface StoreHandle<T, A extends ActionsDecl<T>> {
+    readonly spec: StoreSpec<T, A>;
+    /**
+     * Create a live engine instance (framework machinery and tests only).
+     * @param scopeKey - session id for session-scope instances; suffixes the
+     * persist key so per-session instances persist independently (root-scope
+     * instances omit it).
+     * @returns a fresh instance seeded from `spec.init()`.
+     */
+    create(scopeKey?: string): StoreInstance<T, A>;
+}
+/**
+ * Exclusive-store registration form: the registrant passes the factory itself
+ * and the framework calls it per entry x scope (no shared identity exists).
+ */
+export type StoreFactory = () => StoreHandle<any, any>;
+/** The register `store` option position: a shared handle or an exclusive factory. */
+export type StoreDecl = StoreHandle<any, any> | StoreFactory;
+/** Normalize a store declaration to its handle type (factories yield their return). */
+export type HandleOf<H> = H extends () => infer R ? R : H;
+/**
+ * Handle-keyed baked actions: the `actions` parameter of an inject factory
+ * whose registration declared a store — the same baked callback set the
+ * component receives via {@link PropsStore}.
+ */
+export type BoundActions<H> = H extends StoreHandle<infer T, infer A> ? BakedActions<T, A> : never;
+/**
+ * The store props share, derived from the declared handle: a typed selector
+ * hook plus the baked write set. Components never see the instance itself
+ * (no update/set — reads via useStore, writes via the declared actions only).
+ */
+export type PropsStore<H> = H extends StoreHandle<infer T, infer A> ? {
+    useStore: SnapshotSelectorHook<T>;
+    actions: BakedActions<T, A>;
+} : object;
+/**
+ * The defineStore contract (implementation lives beside this declaration,
+ * bound to the snapshot-store engine): spec in, handle out, with T inferred
+ * from `init` and the actions table constrained by T.
+ */
+export type DefineStore = <T, A extends ActionsDecl<T>>(spec: StoreSpec<T, A>) => StoreHandle<T, A>;
+//# sourceMappingURL=contract.d.ts.map

package/lib/types/index.d.ts

@@ -0,0 +1,92 @@
+import type { ActionsDecl, ObservableSnapshot, StoreHandle, StoreInstance, StoreSpec } from './contract.ts';
+export type { ActionsDecl, BakedActions, BoundActions, DefineStore, HandleOf, MaybeSnapshotSelectorHook, ObservableSnapshot, PropsStore, SnapshotSelectorHook, StoreDecl, StoreFactory, StoreHandle, StoreInstance, StoreSpec, } from './contract.ts';
+/** Writable snapshot store (bare data face; React selector hooks are synthesized in ui-renderer). */
+export interface SnapshotStore<T> extends ObservableSnapshot<T> {
+    /**
+     * Mutate the state through an immer draft.
+     * @param mutator - draft mutator.
+     */
+    update(mutator: (draft: T) => void): void;
+    /**
+     * Replace the state wholesale.
+     * @param next - next state.
+     */
+    set(next: T): void;
+}
+/**
+ * Notify an observer set without allowing one callback to starve the rest.
+ * @param listeners - current observer callbacks; copied before dispatch.
+ * @param label - diagnostic owner prefix.
+ * @param args - callback arguments.
+ */
+export declare function notifySubscribers<Args extends readonly unknown[]>(listeners: Iterable<(...args: Args) => void>, label: string, ...args: Args): void;
+/**
+ * Shallow equality for selector slices (zustand/shallow semantics; travels
+ * with the engine so hook consumers need no zustand dependency).
+ * @param a - left value.
+ * @param b - right value.
+ * @returns whether the values are shallowly equal.
+ */
+export declare function shallowEqual(a: unknown, b: unknown): boolean;
+/**
+ * Create a snapshot store.
+ *
+ * Flush default is 'sync' (controlled inputs need same-tick echo); frame-driven
+ * stores opt into 'raf', where a frame's worth of updates coalesces into one
+ * notification. Known raf-mode tradeoff: a component mounting mid-frame reads
+ * fresh state while existing subscribers hear it next flush — transient
+ * frame-level skew, same nature as the object layer's microtask batching.
+ *
+ * @param init - initial state.
+ * @param opts - flush mode and opt-in persistence (localStorage, keyed by name).
+ * @returns the store.
+ */
+export declare function createSnapshotStore<T>(init: T, opts?: {
+    flush?: 'raf' | 'sync';
+    persist?: {
+        name: string;
+    };
+}): SnapshotStore<T>;
+/** A live engine instance: the contract instance plus the raw engine store. */
+export interface EngineStoreInstance<T, A extends ActionsDecl<T>> extends StoreInstance<T, A> {
+    /** The underlying engine store (framework/test API; components never see it). */
+    readonly store: SnapshotStore<T>;
+}
+/** The engine-backed handle: create() narrowed to the engine instance. */
+export interface EngineStoreHandle<T, A extends ActionsDecl<T>> extends StoreHandle<T, A> {
+    /**
+     * Construct a live engine instance (see the contract JSDoc on
+     * {@link StoreHandle.create} for scopeKey/persist semantics).
+     *
+     * Known boundary: the persist key is the storage identity, so multiple live
+     * instances created under the same resolved key share (and cross-pollute)
+     * one localStorage entry. Instance uniqueness per key is the caller's
+     * responsibility — production is safe because the framework caches one
+     * instance per handle x scope key; tests wanting isolation use distinct
+     * scope keys or persist-free declarations (multi-create freedom is a
+     * feature there, so create() deliberately does not dedupe or throw).
+     * @param scopeKey - session id for session-scope instances; omitted for root scope.
+     * @returns the engine instance.
+     */
+    create(scopeKey?: string): EngineStoreInstance<T, A>;
+}
+/**
+ * Declare a store: initial state, optional persistence, and the full write
+ * set as pure draft mutators. The returned handle is the registration
+ * currency of the store seat — its identity keys instance sharing. Satisfies
+ * ui-slots' DefineStore contract (the handle/instance are the engine-extended
+ * subtypes).
+ *
+ * The `A & ActionsDecl<T>` actions position is load-bearing: T resolves from
+ * `init` in the first inference round, and the intersection then contextually
+ * types each mutator's draft parameter (context-sensitive functions defer),
+ * so call sites write `(d, x: X) => { ... }` with no draft annotation. If a
+ * future TS version breaks this single-literal inference, the design's
+ * documented fallback is currying (`defineStore(init).actions({...})`).
+ * @param decl - init lambda (fresh state per instance), optional persist key, actions table.
+ * @returns the store handle.
+ */
+export declare function defineStore<T, A extends ActionsDecl<T>>(decl: StoreSpec<T, A> & {
+    actions: A & ActionsDecl<T>;
+}): EngineStoreHandle<T, A>;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/invariant.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Package-owned invariant companion for `@deepseek-ai/dsh-client-store`.
+ * @module @deepseek-ai/dsh-client-store/invariant
+ */
+import type { Context } from '@deepseek-ai/cordis';
+/** Cordis companion plugin name. */
+export declare const name = "client-store-invariant";
+/** Service required before the companion can reserve package ownership. */
+export declare const inject: string[];
+/**
+ * Register this package's invariant companion.
+ * @param ctx - Cordis context carrying the invariant service.
+ * @returns the installed registration's disposer after setup succeeds.
+ */
+export declare const apply: (ctx: Context) => Promise<() => void>;
+//# sourceMappingURL=invariant.d.ts.map

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@deepseek-ai/dsh-client-store",
+  "description": "React-free observable and snapshot-store contracts with the shared Zustand/Immer engine",
+  "version": "0.1.2-alpha.2",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/client/store"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./invariant": {
+      "types": "./lib/types/invariant.d.ts",
+      "default": "./lib/invariant.js"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "immer": "^10.1.1",
+    "zustand": "~4.4.7"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.2"
+  },
+  "devDependencies": {
+    "@deepseek-ai/dsh-invariants": "^0.1.2-alpha.2",
+    "@deepseek-ai/cordis": "^4.0.2"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/invariant.js",
+    "lib/types/**/*.d.ts"
+  ]
+}