chain-functions-behavior 1.0.0

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2026 Sergey Khalilov
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,179 @@
+# CFB - Chain Functions Behavior
+
+CFB is a TypeScript framework for turning application scenarios into executable behavior chains. It connects typed events to reusable synchronous and asynchronous functions through declarative strategies, conditions, concurrency rules, and error branches.
+
+The same behavior model can run in a browser, API service, worker, or WebSocket-connected process. Application code owns the domain state and side effects; CFB owns orchestration.
+
+## Manifest
+
+A user story, enterprise architecture diagram, or mind map should translate naturally into a chain of functions. CFB keeps that chain explicit so product behavior does not disappear into UI handlers, transport callbacks, and service-specific control flow.
+
+The framework separates **what should happen** from **where and how each function runs**:
+
+- events select an entrypoint;
+- strategies describe execution order and conditions;
+- actions implement domain behavior;
+- bindings connect browser and server event sources;
+- the runner returns data, patches, events, trace, and a normalized result.
+
+## Runtime Flow
+
+```mermaid
+flowchart LR
+  DOM["DOM event"] --> CFB["Chain behavior binding"]
+  SYNTHETIC["Synthetic event: API, timer, worker"] --> BUS["PubSubBehavior"]
+  TRANSPORT["WebSocket transport"] --> WS["WebSocket bridge"]
+  WS --> BUS
+  BUS --> WS
+  WS --> TRANSPORT
+  BUS --> CFB
+
+  CFB --> CONCURRENCY["Concurrency lane"]
+  CONCURRENCY --> RUNNER["Behavior runner"]
+  RUNNER --> CONDITIONS["Conditions"]
+  CONDITIONS --> ACTIONS["Actions"]
+  ACTIONS --> RESULT["Run result"]
+
+  RUNNER --> DIAGNOSTICS["cfb.* diagnostics"]
+  DIAGNOSTICS --> BUS
+  RESULT --> DIAGNOSTICS
+```
+
+## Installation
+
+```bash
+npm install chain-functions-behavior
+```
+
+## Chain Behavior
+
+`createChainBehavior` is the application-facing runtime. It combines:
+
+- a behavior config with strategies and entrypoints;
+- application actions and conditions;
+- a context value or context provider;
+- bus and DOM event bindings;
+- concurrency and lifecycle options;
+- a behavior runner created for this definition.
+
+`start()` validates the config and installs available bindings. `stop()` removes those bindings. DOM bindings become inactive in runtimes without a DOM, while bus bindings continue to work on both client and server.
+
+```ts
+import { createChainBehavior, createPubSubBehavior } from 'chain-functions-behavior'
+
+type Context = {
+  orders: Map<string, { id: string; status: 'draft' | 'submitted' }>
+}
+
+type Events = {
+  'order.submit': { orderId: string }
+}
+
+const context: Context = {
+  orders: new Map([['order-1', { id: 'order-1', status: 'draft' }]]),
+}
+
+const bus = createPubSubBehavior<Events>()
+
+const behavior = createChainBehavior<Context, unknown, Events>(
+  {
+    events: {
+      '[bus] order.submit': {
+        entrypoint: 'order.submit',
+        options: {
+          concurrency: {
+            mode: 'latest',
+            key: ({ orderId }) => orderId,
+          },
+        },
+      },
+    },
+    actions: {
+      'order.submit': ({ context, input }) => {
+        const order = context.orders.get(input.orderId as string)
+
+        if (order) {
+          order.status = 'submitted'
+        }
+      },
+    },
+    config: {
+      entrypoints: {
+        'order.submit': 'order.submit',
+      },
+      strategies: {
+        'order.submit': {
+          fn: 'order.submit',
+        },
+      },
+    },
+  },
+  {
+    bus,
+    context,
+    onRunnerError: ({ error, entrypoint, runId }) => {
+      console.error('Behavior failed', { error, entrypoint, runId })
+    },
+  }
+)
+
+const started = behavior.start()
+
+bus.emit('order.submit', { orderId: 'order-1' }, { origin: 'api' })
+
+behavior.stop()
+```
+
+`start()` returns active and inactive bindings together with the config validation result. Calling it again replaces bindings installed by the previous start.
+
+## Event Sources
+
+Chain behavior accepts multiple event sources without coupling actions to a transport:
+
+- `[bus] <topic>` consumes typed `PubSubBehavior` events;
+- `[dom] <selector>:<event>` delegates browser events from `document` or a configured root;
+- application code produces synthetic events with `bus.emit()` from API callbacks, timers, workers, or tests;
+- `createBehaviorWs` forwards selected bus envelopes through a WebSocket-like transport and dispatches allowed inbound envelopes back to the bus.
+
+DOM input is normalized to `{ type, value?, dataset, form? }`. For submit events, `preventDefault` defaults to `true`. On the server, DOM bindings are reported as inactive instead of failing behavior startup.
+
+## Concurrency And Lifecycle
+
+Each binding supports `parallel`, `latest`, `queue`, and `drop` modes. A binding can derive a lane key from its payload, allowing unrelated entities to execute independently.
+
+Actions receive an `AbortSignal`. `latest` aborts the previous run in the same lane, and `behavior.stop({ force: true })` aborts all active runs. Cancellation is cooperative: actions must pass the signal to fetches, timers, or other asynchronous work.
+
+CFB publishes lifecycle diagnostics through the configured bus, including `cfb.run.started`, `cfb.run.finished`, `cfb.run.failed`, `cfb.run.cancelled`, `cfb.run.dropped`, and `cfb.queue.overflow`.
+
+## Runnable Example
+
+[`examples/todo-app`](examples/todo-app) is a Bun microapp with DOM bindings, synthetic bus events, and live WebSocket synchronization between browser tabs. Its state, actions, configuration, bindings, and transport setup are intentionally kept together in one `src/app.ts` file.
+
+```bash
+npm run build
+cd examples/todo-app
+bun install
+bun run dev
+```
+
+Open `http://localhost:4173` in two browser tabs to observe event envelopes propagating through the WebSocket bridge.
+
+## Specification
+
+[SPEC.md](SPEC.md) defines the complete technical contract, including:
+
+- runner and registry APIs;
+- built-in actions and conditions;
+- execution modes and condition expressions;
+- runtime helpers, validation, trace, and safety limits;
+- PubSub envelopes and error behavior;
+- chain behavior bindings and concurrency;
+- DOM normalization and WebSocket transport behavior.
+
+## Development
+
+```bash
+npm test
+npm run build
+npm run pack:check
+```

package/examples/job-worker.ts

@@ -0,0 +1,33 @@
+import { createBehaviorRunner, defineBehaviorConfig } from '~/index'
+
+interface JobWorkerContext {
+  worker: { id: string; state: 'idle' | 'busy'; queueSize: number }
+  system: { limits: { maxQueueSize: number } }
+  now: number
+}
+
+export const jobWorkerBehavior = defineBehaviorConfig({
+  version: 1,
+  entrypoints: { 'worker.tick': 'worker.tick' },
+  strategies: {
+    'worker.tick': {
+      fn: 'core.selector',
+      mode: 'selector',
+      then: ['worker.pickQueuedJob', 'worker.idle'],
+    },
+    'worker.pickQueuedJob': {
+      fn: 'jobs.findNext',
+      when: ['and', ['eq', '$context.worker.state', 'idle'], ['gt', '$context.worker.queueSize', 0]],
+      then: ['jobs.reserve', 'jobs.execute'],
+    },
+    'worker.idle': { fn: 'worker.idle' },
+    'jobs.reserve': { fn: 'jobs.reserve' },
+    'jobs.execute': { fn: 'jobs.execute' },
+  },
+})
+
+export const createJobWorkerRunner = () => {
+  const runner = createBehaviorRunner<JobWorkerContext>()
+  runner.loadConfig(jobWorkerBehavior)
+  return runner
+}

package/examples/service-pipeline.ts

@@ -0,0 +1,29 @@
+import { createBehaviorRunner, defineBehaviorConfig } from '~/index'
+
+interface ServicePipelineContext {
+  service: { id: string; status: 'ready' | 'paused'; pendingTasks: number }
+  now: number
+}
+
+export const servicePipelineBehavior = defineBehaviorConfig({
+  version: 1,
+  entrypoints: { 'service.tick': 'service.tick' },
+  strategies: {
+    'service.tick': {
+      fn: 'core.sequence',
+      mode: 'sequence',
+      then: ['service.processPending', 'service.emitStatus'],
+    },
+    'service.processPending': { fn: 'service.processPending' },
+    'service.emitStatus': {
+      fn: 'core.emit',
+      props: { type: 'service.status', payload: { serviceId: '$context.service.id' } },
+    },
+  },
+})
+
+export const createServicePipelineRunner = () => {
+  const runner = createBehaviorRunner<ServicePipelineContext>()
+  runner.loadConfig(servicePipelineBehavior)
+  return runner
+}

package/examples/todo-app/README.md

@@ -0,0 +1,14 @@
+# CFB Todo App
+
+Runnable browser example for CFB DOM bindings, synthetic bus events, and the WebSocket bridge.
+
+```sh
+npm run build
+cd examples/todo-app
+bun install
+bun run dev
+```
+
+Open two browser tabs at `http://localhost:4173`: tasks created, toggled, or removed in one tab are propagated to the other through CFB event envelopes.
+
+`src/app.ts` deliberately keeps state, actions, behavior config, bindings, and transport setup together so the full flow is visible in one file.

package/examples/todo-app/build.ts

@@ -0,0 +1,31 @@
+import Bun, { type BuildOutput } from 'bun'
+import { FileMoverPlugin } from 'bun-file-mover-plugin'
+
+export const build = async (): Promise<BuildOutput> => {
+  const result = await Bun.build({
+    entrypoints: ['./src/app.ts'],
+    outdir: './build',
+    target: 'browser',
+    format: 'esm',
+    splitting: true,
+    minify: false,
+    publicPath: '/',
+    sourcemap: 'external',
+    plugins: [
+      FileMoverPlugin({
+        from: './src/public',
+        to: './build',
+      }),
+    ],
+  })
+
+  if (!result.success) {
+    throw new Error('Todo app build failed')
+  }
+
+  return result
+}
+
+if (import.meta.main) {
+  await build()
+}

package/examples/todo-app/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "cfb-todo-app-example",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "build": "bun run build.ts",
+    "dev": "bun run server.ts",
+    "start": "bun run server.ts"
+  },
+  "dependencies": {
+    "bun-file-mover-plugin": "^1.0.0",
+    "chain-functions-behavior": "file:../..",
+    "serve-static-bun": "^0.5.3"
+  }
+}

package/examples/todo-app/server.ts

@@ -0,0 +1,63 @@
+import Bun, { type Server } from 'bun'
+import { join } from 'node:path'
+import ServeStatic from 'serve-static-bun'
+import { build } from './build'
+
+type SocketData = {
+  id: string
+}
+
+const serve = async (): Promise<Server<SocketData>> => {
+  const port = Number(process.env.PORT ?? 4173)
+  const directory = './build'
+  const root = await Bun.file(join(directory, 'index.html')).text()
+  const staticHandler = ServeStatic(directory, {
+    headers: {
+      'Access-Control-Allow-Origin': '*',
+      'Access-Control-Allow-Methods': 'GET, OPTIONS',
+      'Access-Control-Allow-Headers': 'Content-Type',
+    },
+  })
+
+  const server = Bun.serve<SocketData>({
+    port,
+    async fetch(request, server): Promise<Response | undefined> {
+      const url = new URL(request.url)
+
+      if (url.pathname === '/ws') {
+        const upgraded = server.upgrade(request, { data: { id: crypto.randomUUID() } })
+
+        if (upgraded) {
+          return undefined
+        }
+        return new Response('WebSocket upgrade failed', { status: 400 })
+      }
+
+      try {
+        const response = await staticHandler(request)
+
+        if (response.status === 404 && root) {
+          return new Response(root, { headers: { 'Content-Type': 'text/html' } })
+        }
+        return response
+      } catch {
+        return new Response('Internal Server Error', { status: 500 })
+      }
+    },
+    websocket: {
+      open(socket): void {
+        socket.subscribe('todo-events')
+      },
+      message(socket, message): void {
+        server.publish('todo-events', message)
+      },
+    },
+  })
+
+  console.log(`Todo app is available at http://localhost:${server.port}`)
+
+  return server
+}
+
+await build()
+await serve()

package/examples/todo-app/src/app.ts

@@ -0,0 +1,174 @@
+import {
+  createBehaviorWs,
+  createChainBehavior,
+  createPubSubBehavior,
+  type BehaviorDomForm,
+} from 'chain-functions-behavior'
+import { pick } from 'objwalk'
+
+type Todo = {
+  id: string
+  title: string
+  completed: boolean
+}
+
+type TodoEvents = {
+  'todo.created': Todo
+  'todo.toggled': Pick<Todo, 'id' | 'completed'>
+  'todo.removed': Pick<Todo, 'id'>
+}
+
+type TodoState = {
+  todos: Map<string, Todo>
+}
+
+const state: TodoState = { todos: new Map() }
+const bus = createPubSubBehavior<TodoEvents>()
+
+const getFormValue = (form: BehaviorDomForm | undefined, name: string): string => {
+  const value = form?.[name]
+
+  return typeof value === 'string' ? value.trim() : ''
+}
+
+const render = (): void => {
+  const list = document.querySelector<HTMLUListElement>('[data-todo-list]')
+  const status = document.querySelector<HTMLElement>('[data-todo-status]')
+
+  if (list) {
+    const items = [...state.todos.values()].map((todo) => {
+      const item = document.createElement('li')
+      const toggle = document.createElement('input')
+      const title = document.createElement('span')
+      const remove = document.createElement('button')
+
+      item.className = todo.completed ? 'todo todo-completed' : 'todo'
+      toggle.type = 'checkbox'
+      toggle.checked = todo.completed
+      toggle.dataset.todoToggle = todo.id
+      title.textContent = todo.title
+      remove.type = 'button'
+      remove.dataset.todoRemove = todo.id
+      remove.textContent = 'Remove'
+
+      item.append(toggle, title, remove)
+      return item
+    })
+
+    list.replaceChildren(...items)
+  }
+  if (status) {
+    const completed = [...state.todos.values()].filter((todo) => todo.completed).length
+
+    status.textContent = `${state.todos.size} tasks, ${completed} completed`
+  }
+}
+
+const behavior = createChainBehavior<TodoState, unknown, TodoEvents>(
+  {
+    actions: {
+      'todo.requestCreate': ({ input }) => {
+        const form = input.form as BehaviorDomForm | undefined
+        const title = getFormValue(form, 'title')
+
+        if (title) {
+          bus.emit('todo.created', { id: crypto.randomUUID(), title, completed: false }, { origin: 'ui' })
+        }
+      },
+      'todo.requestToggle': ({ input }) => {
+        const id = pick(input, 'dataset.todoToggle')
+        const todo = typeof id === 'string' ? state.todos.get(id) : undefined
+
+        if (todo) {
+          bus.emit('todo.toggled', { id: todo.id, completed: !todo.completed }, { origin: 'ui' })
+        }
+      },
+      'todo.requestRemove': ({ input }) => {
+        const id = pick(input, 'dataset.todoRemove')
+
+        if (typeof id === 'string') {
+          bus.emit('todo.removed', { id }, { origin: 'ui' })
+        }
+      },
+      'todo.addSynthetic': () => {
+        bus.emit(
+          'todo.created',
+          { id: crypto.randomUUID(), title: 'Synthetic event from an API callback', completed: false },
+          { origin: 'api' }
+        )
+      },
+      'todo.applyCreated': ({ input }) => {
+        const todo = input as Todo
+
+        state.todos.set(todo.id, todo)
+        render()
+      },
+      'todo.applyToggled': ({ input }) => {
+        const update = input as TodoEvents['todo.toggled']
+        const todo = state.todos.get(update.id)
+
+        if (todo) {
+          state.todos.set(update.id, { ...todo, completed: update.completed })
+          render()
+        }
+      },
+      'todo.applyRemoved': ({ input }) => {
+        const update = input as TodoEvents['todo.removed']
+
+        state.todos.delete(update.id)
+        render()
+      },
+    },
+    events: {
+      '[dom] [data-todo-form]:submit': { entrypoint: 'todo.requestCreate' },
+      '[dom] [data-todo-toggle]:click': { entrypoint: 'todo.requestToggle' },
+      '[dom] [data-todo-remove]:click': { entrypoint: 'todo.requestRemove' },
+      '[dom] [data-todo-synthetic]:click': { entrypoint: 'todo.addSynthetic' },
+      '[bus] todo.created': { entrypoint: 'todo.applyCreated' },
+      '[bus] todo.toggled': { entrypoint: 'todo.applyToggled' },
+      '[bus] todo.removed': { entrypoint: 'todo.applyRemoved' },
+    },
+    config: {
+      entrypoints: {
+        'todo.requestCreate': 'todo.requestCreate',
+        'todo.requestToggle': 'todo.requestToggle',
+        'todo.requestRemove': 'todo.requestRemove',
+        'todo.addSynthetic': 'todo.addSynthetic',
+        'todo.applyCreated': 'todo.applyCreated',
+        'todo.applyToggled': 'todo.applyToggled',
+        'todo.applyRemoved': 'todo.applyRemoved',
+      },
+      strategies: {
+        'todo.requestCreate': { fn: 'todo.requestCreate' },
+        'todo.requestToggle': { fn: 'todo.requestToggle' },
+        'todo.requestRemove': { fn: 'todo.requestRemove' },
+        'todo.addSynthetic': { fn: 'todo.addSynthetic' },
+        'todo.applyCreated': { fn: 'todo.applyCreated' },
+        'todo.applyToggled': { fn: 'todo.applyToggled' },
+        'todo.applyRemoved': { fn: 'todo.applyRemoved' },
+      },
+    },
+  },
+  { bus, context: state }
+)
+
+const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:'
+const ws = createBehaviorWs({
+  bus,
+  createSocket: () => new WebSocket(`${protocol}//${window.location.host}/ws`),
+  inboundTopics: ['todo.created', 'todo.toggled', 'todo.removed'],
+  outboundTopics: ['todo.created', 'todo.toggled', 'todo.removed'],
+  origin: 'ws',
+  retry: { initialDelay: 250, maxDelay: 5_000 },
+})
+
+behavior.start()
+ws.start()
+
+queueMicrotask(() => {
+  bus.emit(
+    'todo.created',
+    { id: crypto.randomUUID(), title: 'Synthetic task created after startup', completed: false },
+    { origin: 'api' }
+  )
+})

package/examples/todo-app/src/public/index.html

@@ -0,0 +1,26 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>CFB Todo App</title>
+    <link rel="stylesheet" href="/styles.css" />
+  </head>
+  <body>
+    <main>
+      <header>
+        <p>CFB Todo App</p>
+        <span data-todo-status>0 tasks, 0 completed</span>
+      </header>
+
+      <form data-todo-form>
+        <input name="title" placeholder="What needs doing?" required />
+        <button type="submit">Add task</button>
+      </form>
+
+      <button type="button" data-todo-synthetic>Add synthetic task</button>
+      <ul data-todo-list></ul>
+    </main>
+    <script type="module" src="/app.js"></script>
+  </body>
+</html>

package/examples/todo-app/src/public/styles.css

@@ -0,0 +1,62 @@
+:root {
+  color: #1c242b;
+  background: #f5f7f8;
+  font-family: Arial, sans-serif;
+}
+
+body {
+  margin: 0;
+}
+
+main {
+  width: min(640px, calc(100% - 32px));
+  margin: 48px auto;
+}
+
+header,
+form,
+.todo {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+}
+
+header {
+  justify-content: space-between;
+  border-bottom: 1px solid #ccd4d9;
+  margin-bottom: 20px;
+}
+
+header p {
+  font-size: 24px;
+  font-weight: 700;
+}
+
+input[name='title'] {
+  flex: 1;
+}
+
+button,
+input {
+  font: inherit;
+  padding: 8px 10px;
+}
+
+ul {
+  list-style: none;
+  padding: 0;
+}
+
+.todo {
+  border-bottom: 1px solid #dbe1e4;
+  padding: 10px 0;
+}
+
+.todo span {
+  flex: 1;
+}
+
+.todo-completed span {
+  color: #65727a;
+  text-decoration: line-through;
+}

package/examples/ui-flow.ts

@@ -0,0 +1,27 @@
+import { createBehaviorRunner, defineBehaviorConfig } from '~/index'
+
+interface UiContext {
+  modal: 'buyOre' | null
+}
+
+export const uiBehavior = defineBehaviorConfig({
+  version: 1,
+  entrypoints: { 'settings.save.click': 'settings.save.click' },
+  strategies: {
+    'settings.save.click': {
+      fn: 'ui.validateSettings',
+      then: ['settings.persist', 'ui.closeModal', 'ui.showMessage'],
+      catch: ['ui.showError'],
+    },
+    'settings.persist': { fn: 'settings.persist' },
+    'ui.closeModal': { fn: 'core.patch', props: { patch: { type: 'ui.modal.closed' } } },
+    'ui.showMessage': { fn: 'core.emit', props: { type: 'ui.message', payload: { text: 'Settings saved' } } },
+    'ui.showError': { fn: 'core.emit', props: { type: 'ui.error', payload: { text: 'Could not save settings' } } },
+  },
+})
+
+export const createUiRunner = () => {
+  const runner = createBehaviorRunner<UiContext>()
+  runner.loadConfig(uiBehavior)
+  return runner
+}

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "chain-functions-behavior",
+  "version": "1.0.0",
+  "description": "Chain functions behaviour",
+  "license": "ISC",
+  "author": "Sergey Khalilov",
+  "keywords": [
+    "behavior",
+    "workflow",
+    "action-runner",
+    "rules-engine",
+    "typescript"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/khalilov/chain-functions-behavior.git"
+  },
+  "bugs": {
+    "url": "https://github.com/khalilov/chain-functions-behavior/issues"
+  },
+  "homepage": "https://github.com/khalilov/chain-functions-behavior#readme",
+  "engines": {
+    "node": ">=18"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "types": "./dist/index.d.ts",
+  "module": "./dist/index.js",
+  "files": [
+    "dist",
+    "examples/*.ts",
+    "examples/todo-app/README.md",
+    "examples/todo-app/build.ts",
+    "examples/todo-app/bun.lockb",
+    "examples/todo-app/package.json",
+    "examples/todo-app/server.ts",
+    "examples/todo-app/src",
+    "!dist/**/*.js.map",
+    "!dist/**/*.d.ts.map"
+  ],
+  "directories": {
+    "example": "examples",
+    "test": "test"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "build": "tsup src/index.ts --format esm,cjs --dts --clean",
+    "pack:check": "npm pack --dry-run"
+  },
+  "devDependencies": {
+    "@types/node": "^26.1.0",
+    "prettier": "^3.0.0",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.10"
+  },
+  "sideEffects": false,
+  "dependencies": {
+    "nanoid": "^5.1.16",
+    "objwalk": "^0.2.0"
+  }
+}