Signals

A Signal<T> is a typed reference to a value that will materialize during execution. Triggers and actions return signals immediately while Automate.ax obtains their concrete values later. Signals are not promises. Do not await them.

Access properties

Property access creates another signal:

const email = onNewEmail()
const messageId = email.messageId // Signal<string>
const subjectLength = email.subject.length // Signal<number>

This is shorthand for deriving those properties after email materializes. Chained access works across objects and primitive properties.

Transform values

Use .transform() for calculations that need the concrete value:

const email = onNewEmail()
const normalizedSubject = email.subject.transform((subject) =>
  subject.trim().toLowerCase(),
)

log({ value: normalizedSubject })

Transform functions are pure computations. Automate.ax records their input signals during composition and invokes them only after those values are available. Use the top-level transform function when one result depends on several signals:

const summary = transform(
  [email.from, email.subject],
  (from, subject) => `${from?.address ?? "unknown"}: ${subject}`,
)

Interpolate strings

Use the t tagged template to combine text and signals without resolving them early:

const responseSubject = t`Re: ${email.subject}`

sendEmail({
  to: "person@example.com",
  subject: responseSubject,
  text: "We received your message.",
})

The result is a Signal<string> that depends only on the signals interpolated into the template.

Connect actions

Every action input accepts either its ordinary TypeScript value or a compatible signal. Passing a signal creates a durable dependency:

const matches = searchMessages({ query: "is:unread", limit: 25 })

markAsRead({
  messageIds: matches.transform((messages) =>
    messages.map((message) => message.messageId),
  ),
})

markAsRead becomes ready only after the search succeeds and its transform produces the message IDs.

Execution order

Signal dependencies—not line order—control readiness.

const starred = star({ messageIds: email.messageId })
const labeled = addLabel({ label: "Processed", messageIds: email.messageId })

archive({ messageIds: labeled })

star and addLabel can execute independently. archive waits for addLabel because it consumes labeled; it does not wait for star.

Conditional paths

Use filter to keep a value only when it matches a predicate, or branch when two different sections should depend on a boolean signal:

const urgent = email.subject.transform((subject) => subject.includes("URGENT"))

branch(urgent, () => {
  markAsImportant({ messageIds: email.messageId })
})

Automate.ax still traverses the code deterministically, but only the selected signal path materializes during execution.

Closure and failure

A signal can emit a value, close without one, or fail. Ordinary dependent signals and actions propagate closure or failure instead of executing with a missing value. The closed(signal) and failed(signal) helpers expose those outcomes when an automation needs an explicit recovery path.

Generic JavaScript methods reached through signal property access can lose precise generic inference. Use .transform() when TypeScript reports an imprecise result such as Signal<unknown[]>.

Get started

Concepts

Reference

Access properties

Transform values

Interpolate strings

Connect actions

Execution order

Conditional paths

Closure and failure

​Access properties

​Transform values

​Interpolate strings

​Connect actions

​Execution order

​Conditional paths

​Closure and failure

Access properties

Transform values

Interpolate strings

Connect actions

Execution order

Conditional paths

Closure and failure