Signal Protocol v1

A transport-agnostic application protocol for queries, mutations, and events

A universal coordination layer for real-world operations

Payment captureEscrow releaseUser onboardingRead-model queries
pnpm add @signal/sdk-node # reference runtime

Real workflows

System behavior, shown through real teams.

A clearer way to show what the platform does: familiar roles, concrete operational problems, and outcomes people can understand quickly.

Payoneer logoPayments Platform
Maya Chen, Payments Lead

Maya Chen

Payments Lead · Payoneer

Payment capture

Problem

The same payment can be processed twice when systems retry a request after a timeout or network failure.

Solution

Each payment request is handled as one durable action. If the same request comes back, the system returns the same result instead of charging again.

Result

One payment, one result, and a clean audit trail that other systems can trust.

PayPal logoPayments Platform
Jordan Bell, Operations Manager

Jordan Bell

Operations Manager · PayPal

Escrow release

Problem

More than one internal system may try to release the same funds, which creates real financial risk.

Solution

The release is recorded once as a verified action. Duplicate attempts become safe retries instead of duplicate transfers.

Result

Funds move once, operations stay calm, and compliance teams can trace every step.

Apple logoConsumer Platform
Ava Patel, Platform Engineer

Ava Patel

Platform Engineer · Apple

User onboarding

Problem

Account creation usually triggers several follow-up steps, and retries can accidentally create duplicates or partial setups.

Solution

The account is created once, then welcome emails, provisioning, and downstream tasks happen safely around that single source of truth.

Result

Cleaner onboarding, fewer support issues, and a flow that is easy to understand.

Oracle logoEnterprise Software
Elena Rossi, Support Lead

Elena Rossi

Support Lead · Oracle

Read-only queries

Problem

Some APIs blur reading and writing, which makes them hard to trust and risky to retry.

Solution

Read actions are kept read-only. They return status and data without changing anything in the system.

Result

Support gets reliable answers, retries stay harmless, and behavior remains clear.

Register, execute, and replay the same rules in one flow

Payment capture, escrow release, and onboarding all follow the same pattern: define the schema, register the operation, and replay the same request safely.

1import { createSignalRuntime, defineQuery, defineMutation } from "@signal/sdk-node";
2import { createMemoryIdempotencyStore } from "@signal/runtime";
3
4const runtime = createSignalRuntime({
5 runtimeName: "signal-reference",
6 dispatcher,
7 idempotencyStore: createMemoryIdempotencyStore(),
8});
9
10runtime.registerQuery(
11 defineQuery({
12 name: "payment.status.v1",
13 kind: "query",
14 inputSchema: paymentStatusInputSchema,
15 resultSchema: paymentStatusResultSchema,
16 handler: async (input) => repository.getPayment(input.paymentId),
17 })
18);

Bind the protocol in two ways

The first release includes an in-process binding and an HTTP binding. Both execute the same protocol surface for the real examples in the repository.

Local

In-process

Execute the same registry directly in Node.js for local runs

const result = await runtime.query("payment.status.v1", input);

HTTP

Expose queries, mutations, and capability documents over HTTP

POST /signal/query
POST /signal/mutation
GET /signal/capabilities

Reference server

Run the Node.js implementation that demonstrates payment capture, escrow release, and onboarding end to end

pnpm --filter @signal/reference-server dev

HTTP Endpoints

The HTTP binding carries protocol fields, request context, capability data, and retry metadata.

POST

/signal/query

Execute read-only queries

POST

/signal/mutation

Execute explicit mutations

GET

/signal/capabilities

Discover supported operations

Separation of protocol concerns

The protocol, runtime, bindings, and docs are kept separate so each layer can be read and implemented on its own.

Packages

CO

/packages/core

Envelope, naming, result model, errors, and capability documents

DB

/packages/db

PostgreSQL idempotency store and replay-safe projections

TR

/packages/transport

HTTP binding, in-process execution, and event dispatch

HT

/packages/http

Query and mutation routes plus capability declaration

SE

/packages/security

Extension points for auth and request context

UT

/packages/utils

Helpers used by the runtime and example packages

Lifecycle Phases

1

SPECIFIED

RFCs define names, envelope fields, and semantics

2

REGISTERED

Operations are added to the runtime with schemas

3

RUNNING

Queries execute, mutations can emit, events can replay

const runtime = new SignalRuntime(); // SPECIFIED
runtime.registerMutation("payment.capture.v1", mutation); // REGISTERED
await runtime.mutation("payment.capture.v1", payload, { idempotencyKey }); // RUNNING
const replay = await runtime.mutation("payment.capture.v1", payload, { idempotencyKey }); // same logical result

Read the protocol, then map it to your own flow .

Start with the quickstart, inspect the envelope, and compare the payment capture, escrow release, and onboarding examples with your own implementation.