@cnstra/core 1.0.0

package/README.md

@@ -0,0 +1,226 @@
+# @cnstra/core
+
+**Graph-routed, type-safe orchestration for reactive apps — no global event bus.**
+
+## 🧠 What is CNStra?
+
+**CNStra (Central Nervous System Orchestrator)** models your app as a **typed neuron graph**.  
+You explicitly start a run with `cns.stimulate(...)`; CNStra then performs a **deterministic, hop-bounded traversal** from **collateral → dendrite → returned signal**, step by step.
+
+> **Not pub/sub:** there are no ambient listeners or global `emit`. Only the **signal you return** from a dendrite continues the traversal; returning `null`/`undefined` ends that branch. `maxHops` guards against cycles.
+
+## 🏗️ Core Model
+
+### Neurons
+Units of logic with clear DI and sharp boundaries:
+- **ID** — unique name
+- **Axon** — the neuron’s **output channels** (its collaterals)
+- **Dendrites** — **input receptors** (typed reactions bound to specific collaterals)
+
+### Collaterals
+Typed **output channels** that mint signals:
+- **ID** — string identifier (e.g., `'user:created'`)
+- **Payload** — the shape carried by the signal
+- `createSignal(payload)` → `{ type, payload }`
+
+> **Afferent axon:** the object of collaterals you expose publicly. Its **keys** (e.g., `userCreated`) are what you pass to `cns.stimulate(...)`, not the string IDs.
+
+## 🚀 Quick Start
+
+```bash
+npm install @cnstra/core
+```
+
+```typescript
+import { CNS, collateral, neuron } from '@cnstra/core';
+
+// Define collaterals (communication channels)
+const userCreated = collateral<{ id: string; name: string }>('user:created');
+const userRegistered = collateral<{ userId: string; status: string }>('user:registered');
+
+// Create a neuron
+const userService = neuron('user-service', {
+  userRegistered
+})
+.dendrite({
+  collateral: userCreated,
+  reaction: async (payload, axon) => {
+    const userData = payload as { id: string; name: string };
+    
+    // Process the user creation
+    console.log(`Processing user: ${userData.name}`);
+    
+    // Return the signal that will be processed by CNS
+    return axon.userRegistered.createSignal({
+      userId: userData.id,
+      status: 'completed'
+    });
+  }
+});
+
+// Create the CNS system
+const cns = new CNS({ userCreated }, [userService]);
+
+// Stimulate the system
+await cns.stimulate('userCreated', {
+  id: '123',
+  name: 'John Doe'
+});
+```
+
+## 📚 API Reference
+
+### `collateral<T>(id: string)`
+
+Creates a new collateral (communication channel).
+
+```typescript
+const userEvent = collateral<{ userId: string }>('user:event');
+const simpleEvent = collateral('simple:event'); // No payload type
+```
+
+### `neuron(id: string, axon: Axon)`
+
+Creates a new neuron with the specified axon (output channels).
+
+```typescript
+const myNeuron = neuron('my-neuron', {
+  output: myCollateral
+});
+```
+
+### `neuron.dendrite(dendrite: Dendrite)`
+
+Adds a dendrite (input receptor) to a neuron. Returns the neuron for chaining.
+
+```typescript
+myNeuron
+  .dendrite({
+    collateral: inputCollateral,
+    reaction: async (payload, axon) => {
+      // Process input and return output signal
+      return axon.output.createSignal(result);
+    }
+  });
+```
+
+### `CNS` Class
+
+The main orchestrator that manages signal flow between neurons.
+
+#### Constructor
+```typescript
+new CNS(afferentAxon, neurons)
+```
+
+**Parameters:**
+- `afferentAxon`: Object containing collaterals that can be used as input triggers
+- `neurons`: Array of neurons that process signals
+
+#### `stimulate()` Method
+```typescript
+await cns.stimulate(axonKey, payload, options?)
+```
+
+**Parameters:**
+- `axonKey`: Key from the afferent axon to trigger
+- `payload`: Signal payload with type and data
+- `options`: Optional configuration object
+
+**Options:**
+- `maxHops`: Maximum number of signal hops (default: 1000)
+- `onTrace`: Callback for tracing signal flow
+- `abortSignal`: AbortController signal for cancellation
+
+## 🔄 Key Behavior
+
+### Only Returned Signals Are Processed
+**Important**: In CNS, only the signal returned from the `reaction` function is processed and propagated to other neurons. Signals created with `axon.collateral.createSignal()` but not returned are NOT processed by the system.
+
+```typescript
+const processor = neuron('processor', {
+  output: outputCollateral
+})
+.dendrite({
+  collateral: inputCollateral,
+  reaction: async (payload, axon) => {
+    // This signal is created but NOT processed
+    axon.output.createSignal({ message: 'Hello' });
+    
+    // Only this returned signal is processed
+    return axon.output.createSignal({ message: 'World' });
+  }
+});
+```
+
+### Multiple Neurons on Same Collateral
+Multiple neurons can listen to the same collateral:
+
+```typescript
+const emailService = neuron('email-service', { emailSent })
+  .dendrite({
+    collateral: userCreated,
+    reaction: async (payload, axon) => {
+      return axon.emailSent.createSignal({ to: 'user@example.com' });
+    }
+  });
+
+const notificationService = neuron('notification-service', { notificationSent })
+  .dendrite({
+    collateral: userCreated,
+    reaction: async (payload, axon) => {
+      return axon.notificationSent.createSignal({ message: 'User created' });
+    }
+  });
+
+// Both neurons will process the userCreated signal
+const cns = new CNS({ userCreated }, [emailService, notificationService]);
+```
+
+### Conditional Logic
+```typescript
+const router = neuron('router', {
+  success: successCollateral,
+  error: errorCollateral
+})
+.dendrite({
+  collateral: requestCollateral,
+  reaction: async (payload, axon) => {
+    try {
+      const result = await processRequest(payload);
+      return axon.success.createSignal(result);
+    } catch (error) {
+      return axon.error.createSignal({ error: error.message });
+    }
+  }
+});
+```
+
+## 🧪 Testing
+
+```bash
+npm test
+npm run test:types
+```
+
+## 📦 Build
+
+```bash
+npm run build
+```
+
+## 🚀 Examples
+
+Run the examples to see CNS in action:
+
+```bash
+npm run examples
+```
+
+## 🤝 Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## 📄 License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,140 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CNS: () => CNS,
+  CNSCollateral: () => CNSCollateral,
+  collateral: () => collateral,
+  neuron: () => neuron
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/CNS.ts
+var asArray = (x) => Array.isArray(x) ? x : [x];
+var CNS = class {
+  constructor(afferentLayerAsAxon, neurons) {
+    this.afferentLayerAsAxon = afferentLayerAsAxon;
+    this.neurons = neurons;
+    // index by collateral *type* => list of subscribers
+    this.subIndex = /* @__PURE__ */ new Map();
+    this.buildIndex();
+  }
+  buildIndex() {
+    this.subIndex.clear();
+    for (const neuron2 of this.neurons) {
+      for (const dendrite of neuron2.dendrites) {
+        const key = dendrite.collateral.id;
+        const arr = this.subIndex.get(key) ?? [];
+        arr.push({ neuron: neuron2, dendrite });
+        this.subIndex.set(
+          key,
+          arr
+        );
+      }
+    }
+  }
+  async fanOut(incoming, allowType, seen, queue) {
+    const subscribers = this.subIndex.get(incoming.edgeId);
+    if (!subscribers || subscribers.length === 0) return;
+    for (const { neuron: neuron2, dendrite } of subscribers) {
+      const k = `${neuron2.id}::${incoming.edgeId}::${incoming.spikeId}`;
+      if (seen.has(k)) continue;
+      seen.add(k);
+      const out = await dendrite.reaction(incoming.payload, neuron2.axon);
+      if (out === void 0) continue;
+      for (const spike of asArray(out)) {
+        if (allowType && !allowType(spike.type))
+          continue;
+        queue.push({
+          edgeId: spike.type,
+          payload: spike.payload,
+          hops: incoming.hops + 1,
+          spikeId: incoming.spikeId
+          // keep the same spike id across the cascade
+        });
+      }
+    }
+  }
+  async stimulate(axonKey, payload, opts) {
+    const afferent = this.afferentLayerAsAxon[axonKey];
+    const spikeId = opts?.spikeId || Math.random().toString(36).slice(2);
+    const maxHops = opts?.maxHops ?? 1e3;
+    const queue = [
+      {
+        edgeId: afferent.id,
+        payload,
+        hops: 0,
+        spikeId
+      }
+    ];
+    const seen = /* @__PURE__ */ new Set();
+    while (queue.length) {
+      if (opts?.abortSignal?.aborted) break;
+      const item = queue.shift();
+      opts?.onTrace?.({
+        edgeId: item.edgeId,
+        hops: item.hops,
+        payload: item.payload
+      });
+      if (item.hops >= maxHops) continue;
+      await this.fanOut(
+        item,
+        opts?.allowType,
+        seen,
+        queue
+      );
+    }
+  }
+};
+
+// src/CNSCollateral.ts
+var CNSCollateral = class {
+  constructor(id) {
+    this.id = id;
+  }
+  createSignal(...args) {
+    const payload = args[0];
+    return { type: this.id, payload };
+  }
+};
+
+// src/factory/index.ts
+var collateral = (id) => new CNSCollateral(id);
+var neuron = (id, axon) => {
+  const dendrites = [];
+  const api = {
+    axon,
+    id,
+    dendrites,
+    dendrite(s) {
+      dendrites.push(s);
+      return api;
+    }
+  };
+  return api;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CNS,
+  CNSCollateral,
+  collateral,
+  neuron
+});

package/dist/index.d.cts

@@ -0,0 +1,56 @@
+type TCNSSignal<TType extends string, TPayload> = {
+    type: TType;
+    payload?: TPayload;
+};
+
+declare class CNSCollateral<TId extends string, TPayload> {
+    readonly id: TId;
+    constructor(id: TId);
+    createSignal(...args: [TPayload] extends [undefined] ? [] : [payload: TPayload]): TCNSSignal<TId, TPayload>;
+}
+
+type TCNSAxon<TCId extends string, TInputPayload = unknown> = Record<TCId, CNSCollateral<TCId, TInputPayload>>;
+
+type TCNDendrite<TSenderCollateralIdType extends string, TReceiverAxonCollateralPayload, TReceiverCollateralIdType extends string, TReceiverAxon extends TCNSAxon<TReceiverCollateralIdType, TReceiverAxonCollateralPayload>> = {
+    collateral: CNSCollateral<TSenderCollateralIdType, TReceiverAxonCollateralPayload>;
+    reaction: (payload: TReceiverAxonCollateralPayload, axon: TReceiverAxon) => Promise<ReturnType<CNSCollateral<TReceiverCollateralIdType, TReceiverAxonCollateralPayload>['createSignal']>> | ReturnType<CNSCollateral<TReceiverCollateralIdType, TReceiverAxonCollateralPayload>['createSignal']> | Promise<void> | void;
+};
+
+type TCNSNeuron<TId extends string, TCollateralId extends string, TAxon extends TCNSAxon<TCollateralId, unknown>, TSenderCollateralId extends string, TDendrites extends TCNDendrite<TSenderCollateralId, unknown, TCollateralId, TAxon>[]> = {
+    id: TId;
+    axon: TAxon;
+    dendrites: TDendrites;
+};
+
+declare class CNS<TAfferentCollateralId extends string, TAfferentAxon extends TCNSAxon<TAfferentCollateralId, unknown>, TNeuronId extends string, TCollateralId extends string, TAxon extends TCNSAxon<TCollateralId, any>> {
+    protected readonly afferentLayerAsAxon: TAfferentAxon;
+    protected readonly neurons: TCNSNeuron<TNeuronId, TCollateralId, TAxon, TCollateralId, TCNDendrite<TCollateralId, any, TCollateralId, TAxon>[]>[];
+    private subIndex;
+    constructor(afferentLayerAsAxon: TAfferentAxon, neurons: TCNSNeuron<TNeuronId, TCollateralId, TAxon, TCollateralId, TCNDendrite<TCollateralId, any, TCollateralId, TAxon>[]>[]);
+    private buildIndex;
+    private fanOut;
+    stimulate<K extends keyof TAfferentAxon, TACollateralId extends string>(axonKey: K, payload: ReturnType<TAfferentAxon[K]['createSignal']> & {
+        type: TACollateralId;
+    }, opts?: {
+        maxHops?: number;
+        allowType?: (t: TCollateralId | TAfferentCollateralId) => boolean;
+        onTrace?: (e: {
+            edgeId: TCollateralId | TAfferentCollateralId;
+            hops: number;
+            payload: unknown;
+        }) => void;
+        abortSignal?: AbortSignal;
+        spikeId?: string;
+    }): Promise<void>;
+}
+
+declare const collateral: <TPayload = undefined, TId extends string = string>(id: TId) => CNSCollateral<TId, TPayload>;
+type InterNeuronAPI<TIdType extends string, TSenderCollateralIdType extends string, TReceiverAxonCollateralPayload, TReceiverCollateralIdType extends string, TReceiverAxon extends TCNSAxon<TReceiverCollateralIdType, TReceiverAxonCollateralPayload>> = {
+    id: TIdType;
+    axon: TReceiverAxon;
+    dendrites: TCNDendrite<TSenderCollateralIdType, TReceiverAxonCollateralPayload, TReceiverCollateralIdType, TReceiverAxon>[];
+    dendrite: (s: TCNDendrite<TSenderCollateralIdType, TReceiverAxonCollateralPayload, TReceiverCollateralIdType, TReceiverAxon>) => InterNeuronAPI<TIdType, TSenderCollateralIdType, TReceiverAxonCollateralPayload, TReceiverCollateralIdType, TReceiverAxon>;
+};
+declare const neuron: <TIdType extends string, TSenderCollateralIdType extends string, TReceiverAxonCollateralPayload, TReceiverCollateralIdType extends string, TReceiverAxon extends TCNSAxon<TReceiverCollateralIdType, TReceiverAxonCollateralPayload>>(id: TIdType, axon: TReceiverAxon) => InterNeuronAPI<TIdType, TSenderCollateralIdType, TReceiverAxonCollateralPayload, TReceiverCollateralIdType, TReceiverAxon>;
+
+export { CNS, CNSCollateral, type TCNDendrite, type TCNSAxon, type TCNSNeuron, type TCNSSignal, collateral, neuron };

package/dist/index.d.ts

@@ -0,0 +1,56 @@
+type TCNSSignal<TType extends string, TPayload> = {
+    type: TType;
+    payload?: TPayload;
+};
+
+declare class CNSCollateral<TId extends string, TPayload> {
+    readonly id: TId;
+    constructor(id: TId);
+    createSignal(...args: [TPayload] extends [undefined] ? [] : [payload: TPayload]): TCNSSignal<TId, TPayload>;
+}
+
+type TCNSAxon<TCId extends string, TInputPayload = unknown> = Record<TCId, CNSCollateral<TCId, TInputPayload>>;
+
+type TCNDendrite<TSenderCollateralIdType extends string, TReceiverAxonCollateralPayload, TReceiverCollateralIdType extends string, TReceiverAxon extends TCNSAxon<TReceiverCollateralIdType, TReceiverAxonCollateralPayload>> = {
+    collateral: CNSCollateral<TSenderCollateralIdType, TReceiverAxonCollateralPayload>;
+    reaction: (payload: TReceiverAxonCollateralPayload, axon: TReceiverAxon) => Promise<ReturnType<CNSCollateral<TReceiverCollateralIdType, TReceiverAxonCollateralPayload>['createSignal']>> | ReturnType<CNSCollateral<TReceiverCollateralIdType, TReceiverAxonCollateralPayload>['createSignal']> | Promise<void> | void;
+};
+
+type TCNSNeuron<TId extends string, TCollateralId extends string, TAxon extends TCNSAxon<TCollateralId, unknown>, TSenderCollateralId extends string, TDendrites extends TCNDendrite<TSenderCollateralId, unknown, TCollateralId, TAxon>[]> = {
+    id: TId;
+    axon: TAxon;
+    dendrites: TDendrites;
+};
+
+declare class CNS<TAfferentCollateralId extends string, TAfferentAxon extends TCNSAxon<TAfferentCollateralId, unknown>, TNeuronId extends string, TCollateralId extends string, TAxon extends TCNSAxon<TCollateralId, any>> {
+    protected readonly afferentLayerAsAxon: TAfferentAxon;
+    protected readonly neurons: TCNSNeuron<TNeuronId, TCollateralId, TAxon, TCollateralId, TCNDendrite<TCollateralId, any, TCollateralId, TAxon>[]>[];
+    private subIndex;
+    constructor(afferentLayerAsAxon: TAfferentAxon, neurons: TCNSNeuron<TNeuronId, TCollateralId, TAxon, TCollateralId, TCNDendrite<TCollateralId, any, TCollateralId, TAxon>[]>[]);
+    private buildIndex;
+    private fanOut;
+    stimulate<K extends keyof TAfferentAxon, TACollateralId extends string>(axonKey: K, payload: ReturnType<TAfferentAxon[K]['createSignal']> & {
+        type: TACollateralId;
+    }, opts?: {
+        maxHops?: number;
+        allowType?: (t: TCollateralId | TAfferentCollateralId) => boolean;
+        onTrace?: (e: {
+            edgeId: TCollateralId | TAfferentCollateralId;
+            hops: number;
+            payload: unknown;
+        }) => void;
+        abortSignal?: AbortSignal;
+        spikeId?: string;
+    }): Promise<void>;
+}
+
+declare const collateral: <TPayload = undefined, TId extends string = string>(id: TId) => CNSCollateral<TId, TPayload>;
+type InterNeuronAPI<TIdType extends string, TSenderCollateralIdType extends string, TReceiverAxonCollateralPayload, TReceiverCollateralIdType extends string, TReceiverAxon extends TCNSAxon<TReceiverCollateralIdType, TReceiverAxonCollateralPayload>> = {
+    id: TIdType;
+    axon: TReceiverAxon;
+    dendrites: TCNDendrite<TSenderCollateralIdType, TReceiverAxonCollateralPayload, TReceiverCollateralIdType, TReceiverAxon>[];
+    dendrite: (s: TCNDendrite<TSenderCollateralIdType, TReceiverAxonCollateralPayload, TReceiverCollateralIdType, TReceiverAxon>) => InterNeuronAPI<TIdType, TSenderCollateralIdType, TReceiverAxonCollateralPayload, TReceiverCollateralIdType, TReceiverAxon>;
+};
+declare const neuron: <TIdType extends string, TSenderCollateralIdType extends string, TReceiverAxonCollateralPayload, TReceiverCollateralIdType extends string, TReceiverAxon extends TCNSAxon<TReceiverCollateralIdType, TReceiverAxonCollateralPayload>>(id: TIdType, axon: TReceiverAxon) => InterNeuronAPI<TIdType, TSenderCollateralIdType, TReceiverAxonCollateralPayload, TReceiverCollateralIdType, TReceiverAxon>;
+
+export { CNS, CNSCollateral, type TCNDendrite, type TCNSAxon, type TCNSNeuron, type TCNSSignal, collateral, neuron };

package/dist/index.js

@@ -0,0 +1,110 @@
+// src/CNS.ts
+var asArray = (x) => Array.isArray(x) ? x : [x];
+var CNS = class {
+  constructor(afferentLayerAsAxon, neurons) {
+    this.afferentLayerAsAxon = afferentLayerAsAxon;
+    this.neurons = neurons;
+    // index by collateral *type* => list of subscribers
+    this.subIndex = /* @__PURE__ */ new Map();
+    this.buildIndex();
+  }
+  buildIndex() {
+    this.subIndex.clear();
+    for (const neuron2 of this.neurons) {
+      for (const dendrite of neuron2.dendrites) {
+        const key = dendrite.collateral.id;
+        const arr = this.subIndex.get(key) ?? [];
+        arr.push({ neuron: neuron2, dendrite });
+        this.subIndex.set(
+          key,
+          arr
+        );
+      }
+    }
+  }
+  async fanOut(incoming, allowType, seen, queue) {
+    const subscribers = this.subIndex.get(incoming.edgeId);
+    if (!subscribers || subscribers.length === 0) return;
+    for (const { neuron: neuron2, dendrite } of subscribers) {
+      const k = `${neuron2.id}::${incoming.edgeId}::${incoming.spikeId}`;
+      if (seen.has(k)) continue;
+      seen.add(k);
+      const out = await dendrite.reaction(incoming.payload, neuron2.axon);
+      if (out === void 0) continue;
+      for (const spike of asArray(out)) {
+        if (allowType && !allowType(spike.type))
+          continue;
+        queue.push({
+          edgeId: spike.type,
+          payload: spike.payload,
+          hops: incoming.hops + 1,
+          spikeId: incoming.spikeId
+          // keep the same spike id across the cascade
+        });
+      }
+    }
+  }
+  async stimulate(axonKey, payload, opts) {
+    const afferent = this.afferentLayerAsAxon[axonKey];
+    const spikeId = opts?.spikeId || Math.random().toString(36).slice(2);
+    const maxHops = opts?.maxHops ?? 1e3;
+    const queue = [
+      {
+        edgeId: afferent.id,
+        payload,
+        hops: 0,
+        spikeId
+      }
+    ];
+    const seen = /* @__PURE__ */ new Set();
+    while (queue.length) {
+      if (opts?.abortSignal?.aborted) break;
+      const item = queue.shift();
+      opts?.onTrace?.({
+        edgeId: item.edgeId,
+        hops: item.hops,
+        payload: item.payload
+      });
+      if (item.hops >= maxHops) continue;
+      await this.fanOut(
+        item,
+        opts?.allowType,
+        seen,
+        queue
+      );
+    }
+  }
+};
+
+// src/CNSCollateral.ts
+var CNSCollateral = class {
+  constructor(id) {
+    this.id = id;
+  }
+  createSignal(...args) {
+    const payload = args[0];
+    return { type: this.id, payload };
+  }
+};
+
+// src/factory/index.ts
+var collateral = (id) => new CNSCollateral(id);
+var neuron = (id, axon) => {
+  const dendrites = [];
+  const api = {
+    axon,
+    id,
+    dendrites,
+    dendrite(s) {
+      dendrites.push(s);
+      return api;
+    }
+  };
+  return api;
+};
+export {
+  CNS,
+  CNSCollateral,
+  collateral,
+  neuron
+};

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@cnstra/core",
+  "version": "1.0.0",
+  "description": "Neural network-inspired event flow system for building reactive applications with dependency-injected neurons and synapses",
+  "keywords": [
+    "neural-network",
+    "event-flow",
+    "reactive",
+    "dependency-injection",
+    "neuron",
+    "synapse",
+    "axon",
+    "dendrite",
+    "typescript",
+    "node",
+    "browser"
+  ],
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/abaikov/cnstra.git"
+  },
+  "bugs": {
+    "url": "https://github.com/abaikov/cnstra/issues"
+  },
+  "homepage": "https://github.com/abaikov/cnstra#readme",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --dts --format esm,cjs --tsconfig tsconfig.build.json",
+    "prepublishOnly": "npm run build",
+    "test": "jest",
+    "test:types": "tsd",
+    "examples": "tsx examples/run-examples.ts"
+  },
+  "files": [
+    "dist"
+  ],
+  "author": "Andrei Baikov <abaikov23@gmail.com>",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/jest": "^29.5.12",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.1",
+    "tsup": "^8.5.0",
+    "tsx": "^4.20.5",
+    "typescript": "^5.8.3"
+  }
+}