> ## 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

> Calculate values from one or more signals.

Derivation creates new signals without performing external work. Derivation functions must be synchronous and pure.

## Property access

Accessing a property creates a derived signal:

```ts theme={null}
const request = onHttpRequest()
const path = request.path // Signal<string>
const length = request.path.length // Signal<number>
```

Functions reached through property access remain callable, so `names.join(", ")` returns a signal. Generic JavaScript methods can lose precise inference; use `.transform()` when TypeScript reports a result such as `Signal<unknown[]>`.

## `.transform()`

Use `.transform()` when a result depends on one signal:

```ts theme={null}
const normalizedPath = request.path.transform((path) => path.toLowerCase())
```

An arbitrary transform does not retain a source's `.keyBy()` or `.globally()` annotation. Apply the desired partition to the result before passing it to a [cross-context operator](/reference/signals/coordinate-occurrences).

## `transform()`

Use the top-level function when a result depends on several signals:

```ts theme={null}
import { transform } from "automate.ax"

const requestLine = transform(
  [request.method, request.path],
  (method, path) => `${method} ${path}`,
)
```

The result waits for every input. Input closure closes it, and input failure fails it.

## `t`

Use the `t` tagged template to interpolate signals with static values:

```ts theme={null}
import { t } from "automate.ax"

const subject = t`${request.method} request to ${request.path}`
```

`t` returns `Signal<string>` and requires at least one signal interpolation. Use an ordinary template literal when every value is already in memory.

## `isSignal()`

`isSignal(value)` is a TypeScript type guard for reusable helpers that accept either an ordinary value or a signal:

```ts theme={null}
import { isSignal, type Signal } from "automate.ax"

function normalize(value: string | Signal<string>) {
  return isSignal(value) ? value.transform((text) => text.trim()) : value.trim()
}
```

Most action inputs already accept compatible signals, so ordinary automations rarely need `isSignal`.

See [route and scope work](/reference/signals/route-and-scope) to conditionally materialize derived values, or [inspect outcomes](/reference/signals/inspect-outcomes) to turn closure and failure into values.