@electric-ax/agents 0.2.1 → 0.2.2

package/docs/usage/spawning-and-coordinating.md

@@ -0,0 +1,165 @@
+---
+title: Spawning & coordinating
+titleTemplate: '... - Electric Agents'
+description: >-
+  Spawn child entities, observe existing ones, send messages, and use EntityHandle for coordination.
+outline: [2, 3]
+---
+
+# Spawning & coordinating
+
+Entities coordinate by spawning children, observing other entities, and sending messages.
+
+## spawn
+
+Create a child entity:
+
+```ts
+const child = await ctx.spawn(type, id, args?, opts?)
+```
+
+| Parameter             | Type                      | Description                            |
+| --------------------- | ------------------------- | -------------------------------------- |
+| `type`                | `string`                  | Entity type name (must be registered)  |
+| `id`                  | `string`                  | Unique child ID                        |
+| `args`                | `Record<string, unknown>` | Passed to child handler as `ctx.args`  |
+| `opts.initialMessage` | `unknown`                 | First message delivered to child       |
+| `opts.wake`           | `Wake`                    | When to wake the parent (see below)    |
+| `opts.tags`           | `Record<string, string>`  | Key-value tags applied to the child    |
+| `opts.observe`        | `boolean`                 | Also observe the child (default: true) |
+
+`spawn` is a creation-only operation. Calling it with a `(type, id)` pair that already exists in the entity's manifest throws an error. Use `observe(entity(url))` to get a handle to an existing child.
+
+The `wake` option controls when the parent's handler is re-invoked:
+
+- `'runFinished'` — wake when the child's agent run completes. The child's text response is included in the wake event by default.
+- `{ on: 'runFinished', includeResponse?: boolean }` — same as above, but set `includeResponse: false` to omit the child's text response from the wake event.
+- `{ on: 'change', collections?: string[], debounceMs?: number, timeoutMs?: number }` — wake when specified collections change.
+
+Returns an [`EntityHandle`](#entityhandle).
+
+## EntityHandle
+
+Returned by `spawn` and `observe`:
+
+```ts
+interface EntityHandle {
+  entityUrl: string
+  type?: string
+  db: EntityStreamDB // Read-only TanStack DB
+  events: ChangeEvent[]
+  run: Promise<void> // Resolves when child's run completes
+  text(): Promise<string[]> // Get completed text outputs
+  send(msg: unknown): void // Send follow-up message
+  status(): ChildStatus | undefined
+}
+```
+
+`status()` returns a `ChildStatus` object (or `undefined` if no status is known yet) with `.status`, `.entity_url`, `.entity_type`, and `.key`.
+
+## Waiting for children
+
+Wait for a single child:
+
+```ts
+await child.run
+const output = (await child.text()).join('\n\n')
+```
+
+Wait for multiple children in parallel:
+
+```ts
+const results = await Promise.all(
+  children.map(async ({ handle }) => ({
+    text: (await handle.text()).join('\n\n'),
+  }))
+)
+```
+
+## observe
+
+Subscribe to an existing entity without spawning it:
+
+```ts
+const handle = await ctx.observe(entity(entityUrl), {
+  wake: { on: 'change', collections: ['runs', 'childStatus'] },
+})
+```
+
+Returns an `EntityHandle`. Use `wake` to re-invoke the parent handler when the observed entity changes.
+
+## send
+
+Fire-and-forget message to another entity:
+
+```ts
+ctx.send('/assistant/target-id', { text: 'Hello' })
+ctx.send('/assistant/target-id', payload, { type: 'custom_type' })
+```
+
+Messages appear in the target entity's `inbox` collection.
+
+## sleep
+
+Return the entity to idle state, ending the current handler invocation:
+
+```ts
+ctx.sleep()
+```
+
+The entity remains alive and can be woken again by incoming messages or observed changes.
+
+## Working with existing children
+
+After spawning children in `firstWake`, use `observe` on subsequent wakes to get handles:
+
+```ts
+async handler(ctx) {
+  if (ctx.firstWake) {
+    await ctx.spawn(
+      "worker",
+      "analyst",
+      { systemPrompt: "...", tools: ["read"] },
+      {
+        initialMessage: "Initial task.",
+        wake: "runFinished",
+      }
+    )
+  }
+
+  const analyst = await ctx.observe(entity("/worker/analyst"))
+
+  if (wake.type === "message_received") {
+    analyst.send(wake.payload)
+  }
+}
+```
+
+`spawn` creates the child once. `observe` returns a handle on every wake — it's how you interact with children after creation.
+
+## Workers and authenticated APIs
+
+Workers are least-privilege sandboxes. The built-in `worker` receives a `systemPrompt`, a selected `tools` subset, an optional `sharedDb` config, and the `initialMessage` delivered at spawn time. Never interpolate secrets (`process.env.API_KEY`, auth tokens) into a worker's prompt or message — they are persisted in the entity's durable stream.
+
+**Manager-side prefetch** is the recommended pattern: the manager does the authenticated fetch and passes the raw data to the worker.
+
+```ts
+// In the manager's tool:
+const response = await fetch(apiUrl, {
+  headers: { Authorization: `Bearer ${process.env.API_KEY}` },
+})
+const data = await response.json()
+
+// Pass data, not credentials, to the worker
+await ctx.spawn(
+  'worker',
+  id,
+  { systemPrompt: 'Summarise this data.', tools: ['read'] },
+  {
+    initialMessage: JSON.stringify(data),
+    wake: 'runFinished',
+  }
+)
+```
+
+When the worker needs to make follow-up authenticated calls (pagination, conditional fetches), register a custom worker entity type in your app that closes over the credential at registration time — don't use the built-in `worker` type for this.

package/docs/usage/testing.md

@@ -0,0 +1,76 @@
+---
+title: Testing
+titleTemplate: '... - Electric Agents'
+description: >-
+  Test entity handlers with testResponses for LLM mocking, plus unit and integration testing patterns.
+outline: [2, 3]
+---
+
+# Testing
+
+## testResponses
+
+Test agent handlers without calling the LLM by providing canned responses:
+
+```ts
+ctx.useAgent({
+  systemPrompt: '...',
+  model: 'claude-sonnet-4-5-20250929',
+  tools: [...ctx.electricTools],
+  testResponses: ['Hello! How can I help?'],
+})
+await ctx.agent.run()
+```
+
+For array responses, the runtime picks a response based on the number of prior runs for the entity, which makes repeated wakes deterministic without calling an LLM. The selected string becomes the agent's text output for that run.
+
+## TestResponseFn
+
+For dynamic test responses, provide a function instead of an array:
+
+```ts
+testResponses: async (message, bridge) => {
+  bridge.onTextStart()
+  bridge.onTextDelta('Test response')
+  bridge.onTextEnd()
+  return 'Test response'
+}
+```
+
+The `bridge` parameter gives control over text-level events, letting you simulate tool calls, reasoning steps, and multi-turn interactions. Returning a string emits it as a text block automatically; returning `undefined` emits no automatic text response.
+
+::: info Runtime-managed lifecycle
+The runtime wraps your `TestResponseFn` with `bridge.onRunStart()` / `bridge.onRunEnd()` and step start/end calls automatically. Do not call these yourself — only use text-level bridge methods (e.g. `onTextStart`, `onTextDelta`, `onTextEnd`) or tool-level methods inside the function.
+:::
+
+## Unit testing entity registration
+
+```ts
+import { createEntityRegistry } from '@electric-ax/agents-runtime'
+
+const registry = createEntityRegistry()
+registerAssistant(registry)
+
+test('registers assistant', () => {
+  const entry = registry.get('assistant')
+  expect(entry).toBeDefined()
+  expect(entry!.definition.handler).toBeTypeOf('function')
+})
+```
+
+## Unit testing runtime creation
+
+```ts
+test('creates runtime with types', () => {
+  const runtime = createRuntimeHandler({
+    baseUrl: 'http://localhost:4437',
+    serveEndpoint: 'http://localhost:3000/webhook',
+    registry,
+  })
+  expect(runtime.typeNames).toContain('assistant')
+})
+```
+
+## Integration testing
+
+Integration testing with the full Electric Agents server is possible using the `@electric-ax/agents-server-conformance-tests` package, which provides test server utilities for running against a live server instance.

package/docs/usage/waking-entities.md

@@ -0,0 +1,148 @@
+---
+title: Waking entities
+titleTemplate: '... - Electric Agents'
+description: >-
+  How entity handlers get invoked - the triggers that produce wakes, how wake config threads through spawn/observe/observe(db(...)), and how to read a WakeEvent in a handler.
+outline: [2, 3]
+---
+
+# Waking entities
+
+Entities in Electric Agents are driven by **wakes**. A wake is a single handler invocation triggered by something outside the handler: a new message, a child finishing, a change in an observed stream, or a schedule. Between wakes the entity is idle — no process, no memory, no running handler.
+
+Everything you do to make an entity respond to something — `ctx.spawn(..., { wake })`, `ctx.observe(..., { wake })`, `ctx.send()`, `upsertCronSchedule()` — is ultimately a way to produce a wake.
+
+## The mental model
+
+```
+external event  ─►  wake entry (persisted)  ─►  handler invocation  ─►  WakeEvent passed to handler
+```
+
+1. **External event.** A message arrives, a child transitions, a watched collection changes, a cron fires.
+2. **Wake entry is persisted** to the entity's stream. This is the durability guarantee — wakes survive process restarts, network blips, and crashes. A wake that was written will eventually be delivered to a handler.
+3. **Handler is invoked.** The runtime picks up the wake, loads the entity's state, and calls your handler with a `WakeEvent` describing what triggered this invocation.
+4. **Handler runs.** You read `ctx.events`, inspect `wake`, configure the agent, emit new events. When the handler returns (or calls `ctx.sleep()`), the entity goes idle until the next wake.
+
+This means handlers are re-entrant: the same handler function is called fresh on every wake. Use `ctx.firstWake` for one-time initialization, and `ctx.db.actions` / `ctx.db.collections` to carry state across wakes.
+
+## What produces a wake
+
+There are five things that can wake an entity:
+
+### 1. An incoming message
+
+Any external `/send` (via the CLI, HTTP, or another entity's `ctx.send()`) appends a `message_received` event to the entity's stream, which wakes the handler:
+
+```ts
+ctx.send('/assistant/peer', { text: 'hello' })
+```
+
+The receiving handler sees `wake.type === "message_received"` and finds the payload on `wake.payload`.
+
+### 2. A spawned child
+
+Pass `wake` when spawning a child to control when the parent wakes:
+
+```ts
+const child = await ctx.spawn(
+  'worker',
+  'analysis-1',
+  { systemPrompt: 'Analyse this input.', tools: ['read'] },
+  {
+    initialMessage: 'begin',
+    wake: { on: 'runFinished', includeResponse: true },
+  }
+)
+```
+
+See the full catalog of `Wake` values in [WakeEvent](../reference/wake-event#wake).
+
+### 3. An observed entity
+
+`ctx.observe()` subscribes to another entity's stream without spawning it. Pair it with a `wake` option to re-invoke this handler when the observed stream changes:
+
+```ts
+import { entity } from '@electric-ax/agents-runtime'
+
+await ctx.observe(entity(someEntityUrl), {
+  wake: { on: 'change', collections: ['status'], debounceMs: 250 },
+})
+```
+
+The `entity()` helper wraps a raw URL string into the correct observe target type.
+
+### 4. Shared state
+
+`observe(db(...))` connects to a shared-state stream and, with `wake`, re-wakes the connecting entity when its collections change:
+
+```ts
+await ctx.observe(db('board-1', schema), {
+  wake: { on: 'change', collections: ['findings'] },
+})
+```
+
+### 5. A schedule
+
+Runtime hosts can expose schedule-management tools through `ctx.electricTools`. The current schedule tool set is `list_schedules`, `upsert_cron_schedule`, `upsert_future_send`, and `delete_schedule`. Schedule entries live on the entity's manifest, so they survive restarts and can be updated or cancelled idempotently.
+
+## Reading a WakeEvent
+
+Your handler signature is:
+
+```ts
+handler(ctx: HandlerContext, wake: WakeEvent) => void | Promise<void>
+```
+
+The minimum useful pattern is to branch on `wake.type`:
+
+```ts
+async handler(ctx, wake) {
+  if (wake.type === "message_received") {
+    // external input - reply, dispatch, etc.
+    ctx.useAgent({ ... })
+    await ctx.agent.run()
+    return
+  }
+
+  // everything else (child finished, change, cron, timeout) arrives as type "wake".
+  // Inspect wake.payload for the specific sub-kind.
+  ctx.sleep()
+}
+```
+
+Two wake types reach handlers directly:
+
+- `"message_received"` — an external message was delivered to this entity's inbox.
+- `"wake"` — a synthesised wake for anything else (child finished, collection change, cron, timeout). The specifics are on `wake.payload`. A future-send schedule delivers a message, so it arrives as `"message_received"`.
+
+For the full payload shape (`changes[]`, `finished_child`, `other_children`, `timeout`), see the [wake-type catalog](../reference/wake-event#wake-type-catalog) in the reference.
+
+## Coalescing and idempotency
+
+Multiple external events that arrive while an entity is busy (or between acks) are coalesced into a single wake. The runtime guarantees that:
+
+- A wake covers a contiguous range of offsets in the source stream (`wake.fromOffset`..`wake.toOffset`).
+- `wake.eventCount` tells you how many new events this wake represents.
+- Handlers must be safe to re-run with the same input — at-least-once delivery. Use `ctx.firstWake` and idempotent writes to collections rather than side effects on each wake.
+
+If you need to deduplicate explicitly, key your writes by something stable (the child's entity URL, the message's producer/epoch/seq headers, etc.) and let the collection's primary key do the dedup.
+
+## Debounce and timeouts on `change` wakes
+
+`{ on: 'change' }` has two knobs worth understanding:
+
+- `debounceMs` — if set, rapid-fire changes are batched; the wake fires `debounceMs` after the last change.
+- `timeoutMs` — if set, the wake fires after this interval **even if nothing changed**. Useful for heartbeat-style handlers that need to periodically check state without requiring external events.
+
+Both are optional. If neither is set, every change produces a wake.
+
+## Sleeping between wakes
+
+When the handler finishes (or calls `ctx.sleep()`), the entity returns to idle. The runtime persists the ack offset so the next wake starts from the right place. You don't have to — and shouldn't — hold resources across wakes.
+
+## See also
+
+- [WakeEvent](../reference/wake-event) — full type reference and wake-type catalog.
+- [Spawning & coordinating](./spawning-and-coordinating) — using `wake` with `spawn` and `observe`.
+- [Shared state](./shared-state) — using `wake` with `observe(db(...))`.
+- [Writing handlers](./writing-handlers) — `HandlerContext` and `firstWake` patterns.

package/docs/usage/writing-handlers.md

@@ -0,0 +1,267 @@
+---
+title: Writing handlers
+titleTemplate: '... - Electric Agents'
+description: >-
+  Implement entity handlers using HandlerContext and WakeEvent, with patterns for first wake, messaging, and tool use.
+outline: [2, 3]
+---
+
+# Writing handlers
+
+The handler is the function that runs each time an entity wakes. It receives a `HandlerContext` and a `WakeEvent` describing what triggered the invocation.
+
+## Signature
+
+```ts
+handler(ctx: HandlerContext, wake: WakeEvent) => void | Promise<void>
+```
+
+## HandlerContext
+
+```ts
+interface HandlerContext<TState extends StateProxy = StateProxy> {
+  firstWake: boolean
+  tags: Readonly<EntityTags>
+  entityUrl: string
+  entityType: string
+  args: Readonly<Record<string, unknown>>
+  db: EntityStreamDBWithActions
+  state: TState
+  events: Array<ChangeEvent>
+  actions: Record<string, (...args: unknown[]) => unknown>
+  electricTools: AgentTool[]
+  useAgent: (config: AgentConfig) => AgentHandle
+  useContext: (config: UseContextConfig) => void
+  timelineMessages: (opts?: TimelineProjectionOpts) => Array<TimestampedMessage>
+  insertContext: (id: string, entry: ContextEntryInput) => void
+  removeContext: (id: string) => void
+  getContext: (id: string) => ContextEntry | undefined
+  listContext: () => Array<ContextEntry>
+  agent: AgentHandle
+  spawn: (
+    type: string,
+    id: string,
+    args?: Record<string, unknown>,
+    opts?: {
+      initialMessage?: unknown
+      wake?: Wake
+      tags?: Record<string, string>
+      observe?: boolean
+    }
+  ) => Promise<EntityHandle>
+  observe: (
+    source: ObservationSource,
+    opts?: { wake?: Wake }
+  ) => Promise<EntityHandle | SharedStateHandle | ObservationHandle>
+  mkdb: <T extends SharedStateSchemaMap>(
+    id: string,
+    schema: T
+  ) => SharedStateHandle<T>
+  send: (
+    entityUrl: string,
+    payload: unknown,
+    opts?: { type?: string; afterMs?: number }
+  ) => void
+  setTag: (key: string, value: string) => Promise<void>
+  removeTag: (key: string) => Promise<void>
+  sleep: () => void
+}
+```
+
+### Property reference
+
+| Property           | Description                                                                                                                                             |
+| ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `firstWake`        | `true` on the entity's first activation ever. Use for initialization.                                                                                   |
+| `tags`             | Entity tags -- key/value metadata associated with this entity.                                                                                          |
+| `entityUrl`        | The entity's URL path, e.g. `"/assistant/my-chat"`.                                                                                                     |
+| `entityType`       | The registered type name, e.g. `"assistant"`.                                                                                                           |
+| `args`             | Arguments passed when the entity was spawned. Immutable.                                                                                                |
+| `db`               | The entity's stream database. Use `db.actions` for writes and `db.collections` for reads.                                                               |
+| `state`            | Proxy object keyed by collection name. Each property is a [`StateCollectionProxy`](../reference/state-collection-proxy).                                |
+| `events`           | Change events that triggered this wake.                                                                                                                 |
+| `actions`          | Custom non-CRUD action functions from the entity definition's `actions` factory.                                                                        |
+| `electricTools`    | Host-provided runtime-level tools to pass to `useAgent` when needed. May be empty.                                                                      |
+| `useAgent`         | Configures the LLM agent. Returns an `AgentHandle`. See [Configuring the agent](./configuring-the-agent).                                               |
+| `useContext`       | Declares context sources with token budgets and cache tiers. See [Context composition](./context-composition).                                          |
+| `timelineMessages` | Projects the entity timeline into LLM messages. See [Context composition](./context-composition#timelinemessages).                                      |
+| `insertContext`    | Inserts a durable context entry. See [Context composition](./context-composition#context-entries).                                                      |
+| `removeContext`    | Removes a context entry by id.                                                                                                                          |
+| `getContext`       | Gets a context entry by id, or `undefined` if not found.                                                                                                |
+| `listContext`      | Lists all context entries.                                                                                                                              |
+| `agent`            | The configured agent handle. Call `agent.run()` to start the agent loop.                                                                                |
+| `spawn`            | Creates a child entity. See [Spawning and coordinating](./spawning-and-coordinating).                                                                   |
+| `observe`          | Connects to another entity's stream or shared db. See [Reactive observers](../entities/patterns/reactive-observers) and [Shared state](./shared-state). |
+| `mkdb`             | Creates a new shared state stream. See [Shared state](./shared-state).                                                                                  |
+| `send`             | Sends a message to another entity's inbox. Supports delayed delivery via `afterMs`.                                                                     |
+| `setTag`           | Sets a tag on this entity.                                                                                                                              |
+| `removeTag`        | Removes a tag from this entity.                                                                                                                         |
+| `sleep`            | Returns the entity to idle without re-waking.                                                                                                           |
+
+## WakeEvent
+
+Describes what triggered this handler invocation.
+
+```ts
+type WakeEvent = {
+  source: string
+  type: string
+  fromOffset: number
+  toOffset: number
+  eventCount: number
+  payload?: unknown
+  summary?: string
+  fullRef?: string
+}
+```
+
+| Field        | Description                                                                                                                    |
+| ------------ | ------------------------------------------------------------------------------------------------------------------------------ |
+| `source`     | The stream or entity that caused the wake.                                                                                     |
+| `type`       | The wake type: `"message_received"` for inbox messages or `"wake"` for child completion, observed changes, cron, and timeouts. |
+| `fromOffset` | Start offset of the events that triggered this wake.                                                                           |
+| `toOffset`   | End offset of the events that triggered this wake.                                                                             |
+| `eventCount` | Number of new events since last wake.                                                                                          |
+| `payload`    | Optional payload from the trigger event.                                                                                       |
+| `summary`    | Optional human-readable summary.                                                                                               |
+| `fullRef`    | Optional full reference string for the trigger.                                                                                |
+
+## Typical handler pattern
+
+Most handlers follow the same structure: initialize state on first wake, configure the agent, run the agent.
+
+```ts
+registry.define('assistant', {
+  description: 'A general-purpose assistant',
+  state: {
+    status: { primaryKey: 'key' },
+  },
+
+  async handler(ctx) {
+    if (ctx.firstWake) {
+      ctx.db.actions.status_insert({ row: { key: 'current', value: 'idle' } })
+    }
+
+    ctx.useAgent({
+      systemPrompt: 'You are a helpful assistant.',
+      model: 'claude-sonnet-4-5-20250929',
+      tools: [...ctx.electricTools],
+    })
+    await ctx.agent.run()
+  },
+})
+```
+
+## AgentConfig
+
+Passed to `ctx.useAgent()`:
+
+```ts
+interface AgentConfig {
+  systemPrompt: string
+  model: string | Model<any>
+  provider?: KnownProvider
+  tools: AgentTool[]
+  streamFn?: StreamFn
+  testResponses?: string[] | TestResponseFn
+}
+```
+
+## firstWake
+
+`ctx.firstWake` is `true` only on the entity's very first activation. Use it for one-time initialization:
+
+```ts
+async handler(ctx) {
+  if (ctx.firstWake) {
+    ctx.db.actions.status_insert({ row: { key: 'current', value: 'idle' } })
+    ctx.db.actions.counters_insert({ row: { key: 'runs', value: 0 } })
+  }
+  // ...
+}
+```
+
+On subsequent wakes (new messages, child completion, etc.), `firstWake` is `false`.
+
+## sleep
+
+Call `ctx.sleep()` to return the entity to idle without triggering a re-wake. The handler exits and the entity waits for the next external event.
+
+```ts
+async handler(ctx, wake) {
+  if (wake.type === 'some-condition') {
+    // Nothing to do right now
+    ctx.sleep()
+    return
+  }
+  // Otherwise, run the agent
+  ctx.useAgent({ ... })
+  await ctx.agent.run()
+}
+```
+
+## Using spawn args
+
+Arguments passed at spawn time are available as `ctx.args`. This is how you parameterize entity behavior:
+
+```ts
+// Spawning side
+const child = await ctx.spawn('worker', 'analysis-1', {
+  systemPrompt: 'You are an analyst.',
+  tools: ['read'],
+})
+
+// Worker handler
+async handler(ctx) {
+  const { systemPrompt } = ctx.args as { systemPrompt: string }
+  ctx.useAgent({
+    systemPrompt,
+    model: 'claude-sonnet-4-5-20250929',
+    tools: [...ctx.electricTools],
+  })
+  await ctx.agent.run()
+}
+```
+
+## Adding custom tools
+
+Combine `ctx.electricTools` with custom tools:
+
+```ts
+async handler(ctx) {
+  const myTool: AgentTool = {
+    name: 'lookup',
+    label: 'Lookup',
+    description: 'Looks up a value by key',
+    parameters: Type.Object({
+      key: Type.String({ description: 'The key to look up' }),
+    }),
+    execute: async (_toolCallId, params) => {
+      const { key } = params as { key: string }
+      const row = ctx.db.collections.kv?.get(key)
+      return {
+        content: [{ type: 'text', text: row ? JSON.stringify(row) : 'Not found' }],
+        details: {},
+      }
+    },
+  }
+
+  ctx.useAgent({
+    systemPrompt: 'You are an assistant with lookup capabilities.',
+    model: 'claude-sonnet-4-5-20250929',
+    tools: [...ctx.electricTools, myTool],
+  })
+  await ctx.agent.run()
+}
+```
+
+## Sending messages
+
+Use `ctx.send()` to deliver a message to another entity's inbox:
+
+```ts
+ctx.send('/worker/task-1', { action: 'process', data: payload })
+ctx.send('/worker/task-1', payload, { type: 'custom_type' })
+```
+
+The target entity will be woken to process the message.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@electric-ax/agents",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "Built-in Electric Agents runtimes such as Horton and worker",
   "repository": {
     "type": "git",
@@ -52,6 +52,7 @@
   },
   "files": [
     "dist",
+    "docs",
     "skills"
   ],
   "sideEffects": false,