> ## Documentation Index
> Fetch the complete documentation index at: https://docs.automate.ax/llms.txt
> Use this file to discover all available pages before exploring further.

> ## Agent Instructions
> Automate.ax automations are TypeScript programs.
> Use Bun for installation and command examples.
> Use Automate.ax for the product name and automate.ax for the package, CLI, and domain.
> Treat documented public APIs as current; do not invent transitional or deprecated names.

# Derive signal values

> Project, calculate, and format values that materialize during execution.

Triggers and actions return signals while Automate.ax plans the automation. Derive the value you need synchronously, then pass that signal to the next action.

```ts automations/describe-request.automation.ts theme={null}
import { automation, onHttpRequest, respondToHttpRequest, t } from "automate.ax"

export default automation("Describe request path", () => {
  const request = onHttpRequest()
  const normalized = request.path.transform((path) => path.toLowerCase())

  respondToHttpRequest({
    body: t`${normalized} has ${normalized.length} characters`,
    requestId: request.requestId,
  })
})
```

## Read a property

Access a property directly on the signal. `request.path` is a `Signal<string>`; `request.path.length` is a `Signal<number>`. Chained access records the dependency without reading the value during planning.

Use [`transform`](/reference/runtime/signal-operators#transform) when you need to call a value method, calculate a new value, combine signals, or branch inside a pure function.

## Build a string

Use [`t`](/reference/runtime/signal-operators#t) when a string contains signals:

```ts theme={null}
const prefix = "Incoming"
const summary = t`${prefix}: ${request.method} ${request.path}`
```

An ordinary template literal tries to convert each signal before its value exists and throws:

```ts theme={null}
const summary = `${request.method} ${request.path}` // Throws during planning
```

Use an ordinary template literal inside a transform callback or action handler, where the values already exist.

## Accept a value or signal

Use [`isSignal`](/reference/runtime/signal-operators#issignal) in a reusable helper whose input permits either form. Action inputs already accept compatible signals, so ordinary automation code rarely needs the check.

Derivation functions must stay synchronous and pure. Actions own network calls, file writes, and other external work.