Try it

Pick a scenario, read its rules, change the request and see what the engine decides. Everything runs in this page: nothing to install, nothing sent anywhere.

Step 1: Pick a scenario

Denied by a server-only rule the transfer ruleset inherits from its parent.

Step 2: Read the rules

Ruleset to evaluate

The engine evaluates payments-transfer.ruleset.yaml. It extends acme.org.base, so those rules apply too, and it may only tighten them.

acme.payments.transferevaluated
extendsacme.org.baseparent

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

# Feature-level ruleset. Inherits the organisation baseline, tightens it,
# and adds component- and field-level rules for the transfer screen and API.
ruleCascade: 1.0.0
kind: RuleSet

metadata:
  id: acme.payments.transfer
  version: 1.0.0
  title: Retail payments - create and manage transfers
  owner: payments-platform
  status: active
  labels: { domain: payments, tier: "1" }

scope:
  - { level: enterprise, id: acme-group }
  - { level: organization, id: acme }
  - { level: businessUnit, id: retail-banking }
  - { level: application, id: payments-hub }
  - { level: feature, id: transfers }

extends:
  - { ruleset: acme.org.base, version: ^1.2.0 }

entities:
  Transfer:
    schema: { $ref: "./payments.openapi.yaml#/components/schemas/Transfer" }

params:
  internationalFeeRate:
    type: number
    default: 0.015
    description: Fee as a fraction of the amount for cross-border transfers.
  largeTransferThreshold:
    type: number
    default: 10000

overrides:
  params:
    maxTransferAmount: 25000        # retail tightens the org limit of 50000
  rules:
    - rule: org.transfer.memo-recommended
      set: { severity: warning }
      reason: Retail operations needs memos for dispute handling.

conflictPolicy: priority

rules:
  # ---- field-level validation -------------------------------------------
  - id: transfer.amount.positive
    kind: validation
    title: Amount must be greater than zero
    target: { entity: Transfer, component: amount-panel, field: /amount }
    operations: [create, update]
    triggers: [change, submit]
    when: { op: exists, args: [ { var: data.amount } ] }
    assert: { op: gt, args: [ { var: data.amount }, 0 ] }
    severity: error
    finding: { code: PAY-TRF-001, message: transfer.amountPositive }

- id: transfer.swift.required-international
    kind: validation
    title: SWIFT/BIC is required for international transfers
    target: { entity: Transfer, component: beneficiary-panel, field: /beneficiary/swiftCode }
    operations: [create, update]
    triggers: [blur, submit]
    when: { op: eq, args: [ { var: data.type }, international ] }
    assert:
      op: and
      args:
        - { op: not, args: [ { op: empty, args: [ { var: data.beneficiary.swiftCode } ] } ] }
        - { op: matches, args: [ { var: data.beneficiary.swiftCode }, "^[A-Z]{6}[A-Z0-9]{2}([A-Z0-9]{3})?$" ] }
    severity: error
    finding: { code: PAY-TRF-002, message: transfer.swiftRequired }

# ---- cross-field validation -------------------------------------------
  - id: transfer.large.review-warning
    kind: validation
    title: Large transfers need a conscious confirmation
    target: { entity: Transfer, component: amount-panel, fields: [/amount, /beneficiary/name] }
    operations: [create]
    triggers: [submit]
    when: { op: exists, args: [ { var: data.amount } ] }
    assert: { op: lt, args: [ { var: data.amount }, { var: params.largeTransferThreshold } ] }
    severity: warning
    acknowledgement: required
    finding:
      code: PAY-TRF-003
      message: transfer.largeAmount
      args: { name: { var: data.beneficiary.name } }

# ---- collection rule, evaluated per element ---------------------------
  - id: transfer.split.share-positive
    kind: validation
    title: Every split share must be positive
    target: { entity: Transfer, component: splits-grid, field: /share }
    operations: [create, update]
    forEach: /splits
    assert: { op: gt, args: [ { var: item.share }, 0 ] }
    severity: error
    finding: { code: PAY-TRF-004, message: transfer.splitSharePositive }

# ---- update / delete rules use the stored state -----------------------
  - id: transfer.update.currency-immutable
    kind: validation
    title: Currency cannot change after creation
    target: { entity: Transfer, field: /currency }
    operations: [update]
    enforcement: server
    assert: { op: eq, args: [ { var: data.currency }, { var: original.currency } ] }
    severity: error
    finding: { code: PAY-TRF-005, message: transfer.currencyImmutable }

- id: transfer.delete.only-draft
    kind: validation
    title: Only draft transfers can be deleted
    target: { entity: Transfer }
    operations: [delete]
    enforcement: server
    assert: { op: eq, args: [ { var: original.status }, draft ] }
    severity: error
    finding: { code: PAY-TRF-006, message: transfer.deleteOnlyDraft }

# ---- custom business action -------------------------------------------
  - id: transfer.approve.four-eyes
    kind: validation
    title: The creator cannot approve their own transfer
    target: { entity: Transfer }
    operations: [approve]
    enforcement: server
    overridePolicy: locked
    assert: { op: ne, args: [ { var: actor.id }, { var: original.createdBy } ] }
    severity: error
    finding: { code: PAY-TRF-007, message: transfer.fourEyes }

# ---- component / field state ------------------------------------------
  - id: transfer.swift.show-for-international
    kind: state
    title: SWIFT field appears only for international transfers
    target: { entity: Transfer, component: beneficiary-panel, field: /beneficiary/swiftCode }
    operations: [create, update]
    triggers: [load, change]
    enforcement: client
    when: { op: eq, args: [ { var: data.type }, international ] }
    effects:
      - field: /beneficiary/swiftCode
        set: { visible: true, required: true }

- id: transfer.read.mask-for-non-owners
    kind: state
    title: Hide the internal risk score from non-risk staff
    target: { entity: Transfer, component: details-panel, field: /riskScore }
    operations: [read]
    when: { op: not, args: [ { op: in, args: [ risk-officer, { op: coalesce, args: [ { var: actor.roles }, { op: list, args: [] } ] } ] } ] }
    effects:
      - field: /riskScore
        set: { visible: false }

# ---- computed values ---------------------------------------------------
  - id: transfer.fee.international
    kind: compute
    title: International fee
    target: { entity: Transfer, component: amount-panel, field: /fee }
    operations: [create, update]
    triggers: [change, submit]
    when:
      op: and
      args:
        - { op: eq, args: [ { var: data.type }, international ] }
        - { op: exists, args: [ { var: data.amount } ] }
    assign:
      - field: /fee
        mode: always
        value: { op: mul, args: [ { var: data.amount }, { var: params.internationalFeeRate } ] }

# ---- post-persist action ----------------------------------------------
  - id: transfer.created.notify-risk
    kind: action
    title: Tell risk about large transfers
    target: { entity: Transfer }
    operations: [create]
    enforcement: server
    when:
      op: and
      args:
        - { op: exists, args: [ { var: data.amount } ] }
        - { op: gte, args: [ { var: data.amount }, { var: params.largeTransferThreshold } ] }
    commands:
      - name: risk.large-transfer-created
        type: event
        ref: com.acme.payments.transfer.large.v1
        payload:
          transferId: { var: data.id }
          amount: { var: data.amount }
        idempotencyKey: [ large-transfer, { var: data.id } ]

messages:
  en:
    transfer.amountPositive: "Amount must be greater than zero."
    transfer.swiftRequired: "A valid SWIFT/BIC code is required for international transfers."
    transfer.largeAmount: "This is a large transfer to {name}. Please confirm the details."
    transfer.splitSharePositive: "Each split share must be greater than zero."
    transfer.currencyImmutable: "Currency cannot be changed once the transfer exists."
    transfer.deleteOnlyDraft: "Only draft transfers can be deleted."
    transfer.fourEyes: "You cannot approve a transfer you created."

bindings:
  openapi:
    - document: ./payments.openapi.yaml
      entity: Transfer
      operations:
        create: createTransfer
        read: getTransfer
        update: updateTransfer
        delete: deleteTransfer
        approve: approveTransfer

tests:
  - name: valid domestic transfer is allowed, memo missing is a non-blocking warning
    entity: Transfer
    operation: create
    given:
      data: { id: t-1, type: domestic, amount: 120.50, currency: USD, beneficiary: { name: Jo Lee, country: US } }
    expect:
      decision: allow
      findings:
        - { rule: org.transfer.memo-recommended, blocking: false }
      commands: []

- name: blocked country is denied on the server
    entity: Transfer
    operation: create
    given:
      data: { id: t-2, type: international, amount: 500, currency: USD, memo: gift,
              beneficiary: { name: X, country: KP, swiftCode: ABCDKPPY } }
    expect:
      decision: deny
      findings:
        - rule: org.transfer.blocked-country
          status: open
          blocking: true
          fields: [/beneficiary/country]
          message: Transfers to KP are not permitted.
      effects:
        - { type: value, field: /fee, value: 7.5 }

- name: blocked-country rule is not visible to the client channel
    entity: Transfer
    operation: create
    channel: client
    given:
      data: { id: t-2, type: international, amount: 500, currency: USD, memo: gift,
              beneficiary: { name: X, country: KP, swiftCode: ABCDKPPY } }
    expect:
      decision: allow
      findings: []
      effects:
        - { type: state, field: /beneficiary/swiftCode, set: { visible: true, required: true } }

- name: missing SWIFT on international transfer
    entity: Transfer
    operation: create
    given:
      data: { id: t-3, type: international, amount: 900, currency: EUR, memo: rent,
              beneficiary: { name: Ana, country: ES } }
    expect:
      decision: deny
      findings:
        - { rule: transfer.swift.required-international, fields: [/beneficiary/swiftCode] }

- name: large transfer blocks until the warning is acknowledged
    entity: Transfer
    operation: create
    given:
      data: { id: t-4, type: domestic, amount: 12000, currency: USD, memo: car,
              beneficiary: { name: Sam, country: US } }
    expect:
      decision: deny
      findings:
        - rule: transfer.large.review-warning
          status: open
          blocking: true
          message: This is a large transfer to Sam. Please confirm the details.
      commands: []

- name: acknowledged large transfer is allowed and emits the risk event
    entity: Transfer
    operation: create
    given:
      data: { id: t-4, type: domestic, amount: 12000, currency: USD, memo: car,
              beneficiary: { name: Sam, country: US } }
      resolutions:
        - { rule: transfer.large.review-warning, type: acknowledge }
    expect:
      decision: allow
      findings:
        - { rule: transfer.large.review-warning, status: acknowledged, blocking: false }
      commands: [risk.large-transfer-created]

- name: over the tightened retail limit is denied for an ordinary user
    entity: Transfer
    operation: create
    given:
      data: { id: t-5, type: domestic, amount: 30000, currency: USD, memo: house,
              beneficiary: { name: Sam, country: US } }
      actor: { id: u-1, roles: [teller] }
      resolutions:
        - { rule: transfer.large.review-warning, type: acknowledge }
        - { rule: org.transfer.amount-limit, type: accept-risk, justification: customer insisted }
    expect:
      decision: deny
      findings:
        - rule: org.transfer.amount-limit
          status: open
          blocking: true
          message: Amount exceeds the single-transfer limit of 25000.
        - { rule: transfer.large.review-warning, status: acknowledged }

- name: a risk officer can accept the limit breach with a justification
    entity: Transfer
    operation: create
    given:
      data: { id: t-5, type: domestic, amount: 30000, currency: USD, memo: house,
              beneficiary: { name: Sam, country: US } }
      actor: { id: u-9, roles: [risk-officer] }
      resolutions:
        - { rule: transfer.large.review-warning, type: acknowledge }
        - { rule: org.transfer.amount-limit, type: accept-risk, justification: verified source of funds }
    expect:
      decision: allow
      findings:
        - { rule: org.transfer.amount-limit, status: accepted, blocking: false }
        - { rule: transfer.large.review-warning, status: acknowledged }
      commands: [risk.large-transfer-created]

- name: per-element rule reports the exact array index
    entity: Transfer
    operation: create
    given:
      data: { id: t-6, type: domestic, amount: 100, currency: USD, memo: split,
              beneficiary: { name: Sam, country: US },
              splits: [ { account: a, share: 60 }, { account: b, share: 0 } ] }
    expect:
      decision: deny
      findings:
        - { rule: transfer.split.share-positive, fields: [/splits/1/share] }

- name: currency change on update is denied
    entity: Transfer
    operation: update
    given:
      data: { id: t-7, type: domestic, amount: 100, currency: EUR, beneficiary: { name: Sam, country: US } }
      original: { id: t-7, type: domestic, amount: 100, currency: USD, status: draft, createdBy: u-1 }
    expect:
      decision: deny
      findings:
        - { rule: transfer.update.currency-immutable }

- name: delete of a submitted transfer is denied
    entity: Transfer
    operation: delete
    given:
      data: {}
      original: { id: t-8, status: submitted, createdBy: u-1 }
    expect:
      decision: deny
      findings:
        - { rule: transfer.delete.only-draft }

- name: four-eyes on the custom approve action
    entity: Transfer
    operation: approve
    given:
      data: {}
      original: { id: t-9, status: submitted, createdBy: u-1 }
      actor: { id: u-1, roles: [approver] }
    expect:
      decision: deny
      findings:
        - { rule: transfer.approve.four-eyes }

- name: read hides the risk score from non-risk staff
    entity: Transfer
    operation: read
    given:
      data: { id: t-10, riskScore: 71 }
      actor: { id: u-1, roles: [teller] }
    expect:
      decision: allow
      findings: []
      effects:
        - { type: state, field: /riskScore, set: { visible: false } }

- name: on the client a change trigger runs only rules that listen to change
    entity: Transfer
    operation: create
    channel: client
    given:
      trigger: change
      data: { id: t-11, type: international, amount: -5, currency: USD, beneficiary: { name: Ana, country: ES } }
    expect:
      decision: deny
      findings:
        - { rule: transfer.amount.positive, fields: [/amount], message: Amount must be greater than zero. }
      effects:
        - { type: value, field: /fee, value: -0.075 }
        - { type: state, field: /beneficiary/swiftCode }

Step 3: Edit the request

ServerClient

Server runs everything the API enforces. Client runs only what the browser is allowed to see: server-only rules are hidden.

Step 4: Run it

Evaluate runs this request against the rules. Check rules validates the YAML, runs the load checks and every golden test.

Shortcuts

Ctrl+Enter: Evaluate (in any editor)
Ctrl+Shift+Enter: Check rules
← →: Move between file tabs

On a Mac, use ⌘ instead of Ctrl.

Step 5: Read the result

Starting the engine...

Try this next

0 of 2 done

Switch to the client channel (not done yet)
The blocked-country rule is server-only, so the browser never sees it: ORG-TRF-001 disappears and the transfer is allowed.
Send the transfer to Germany ("country": "DE") (not done yet)
Even on the server, where every rule runs, nothing blocks it: allowed, and the fee is still computed.

What to notice in this scenario

The decision is deny, and the finding ORG-TRF-001 does not come from the transfer ruleset at all: it comes from acme.org.base, the organisation ruleset that payments-transfer extends (open its tab). Its rule is locked and server-only (enforcement: server), so switch the channel to client and evaluate again: the browser never receives the list of blocked countries, and the same request shows no finding there. The fee of 7.5 is a computed value from a compute rule.

From examples/contracts/payments-transfer.ruleset.yaml, golden test "blocked country is denied on the server".

How this works

The engine runs in this page, in a Web Worker. It is the TypeScript runtime, which passes the same conformance suite as every other engine, so the answer is the one Java, Go, Python and the rule-cascade command give.

Like rule-cascade check, the playground registers the three conformance operators (x-luhn, x-test-reverse, x-test-sum), and Check rules runs every golden test in the tests of each ruleset. A ruleset names its parents in extends and its entity schema in $ref: both are found among the tabs by id and by file name.

To run the same thing on your machine, download the command and follow the quickstart.

1Step 1: Pick a scenario

2Step 2: Read the rules

3Step 3: Edit the request