# Rulealize Registry

> Every operation the 18 indexed plugins register — 103 of them — with its kind and the keys it takes, and the 15 published rule sets a document can hold. Read out of the packages on nuget.org and rebuilt every day; last checked 2026-11-01 11:01 UTC.

A Rulealize rule set is a JSON document, and nothing in it is built in: every node is an
operation that a plugin registers under its own namespace, and the document names those
plugins in `requires`. This is the Registry's index of them — which plugin provides which
operation, and which rule sets are published — written for whoever is about to write one.
How a rule set is laid out is Rulealize's quick guide:
https://raw.githubusercontent.com/reny-develop/Rulealize/main/doc/ruleset-quickguide.md

## Before writing one

- Write only operations listed here, with only the keys their form shows. An `op` that is
  not registered, or one whose plugin `requires` does not name, is refused when the rule
  set is built. A name is exact: nothing is looked up from one that is nearly right.
- Every plugin the document reaches for goes in `requires`, as the line given under it —
  the plugin of each operation used, and the plugin that reserves each shorthand
  character used (`$`, `@`, `#`, …).
- A form is the JSON that names a node, with every value replaced by what may stand there:
  `<expression>` is any expression node or a JSON literal; `<expression:Number>` has to be
  of that kind (`Boolean`, `Number`, `Text`, `Sequence`, `Record`); a lowercase one such as
  `<expression:coord>` is an opaque value of that plugin's own type; `<state field>` is a
  state field written `"$name"`; `<schema node>`, or `<schema>`, is a schema node;
  `<integer>` and `<boolean>` are literals and never expressions; `"<name>"` and the like
  are literal strings; `…` repeats the element before it. A trailing `// static` means the
  key takes a literal, `// optional` that it may be left out, `// required with "<key>"`
  that it goes with that key, and a key with none of these is required and takes an
  expression. The whole notation:
  https://raw.githubusercontent.com/reny-develop/Rulealize.Abstraction/main/doc/specification-notation.md
- Each form is read out of the plugin's own specification, on its repository's main
  branch, whenever this page is rebuilt. Where none was found the operation is still
  listed, with the specification to read instead.

## Plugins

### Rulealize.Plugin.Arithmetic 1.2.0

Namespace `math`. No shorthand character.
requires: { "plugin": "Rulealize.Plugin.Arithmetic", "version": "^1.2" }
Specification: https://raw.githubusercontent.com/reny-develop/Rulealize.Plugin.Arithmetic/main/doc/specification.md
Its package describes it: Arithmetic over Rulealize's decimal Number values: math.add, math.sub, math.mul, math.div, math.mod, math.min, math.max, math.abs, math.round and math.pow.

#### math.abs — expression

```jsonc
{ "op": "math.abs", "value": <expression:Number> }
```

#### math.add — expression

```jsonc
{ "op": "math.add", "of": [<expression:Number>, …] }
```

#### math.div — expression

```jsonc
{ "op": "math.div", "left": <expression:Number>, "right": <expression:Number> }
```

#### math.max — expression

```jsonc
{ "op": "math.max", "of": [<expression:Number>, …] }
```

#### math.min — expression

```jsonc
{ "op": "math.min", "of": [<expression:Number>, …] }
```

#### math.mod — expression

```jsonc
{ "op": "math.mod", "left": <expression:Number>, "right": <expression:Number> }
```

#### math.mul — expression

```jsonc
{ "op": "math.mul", "of": [<expression:Number>, …] }
```

#### math.pow — expression

```jsonc
{ "op": "math.pow", "base": <expression:Number>, "exponent": <expression:Number> }
```

#### math.round — expression

```jsonc
{
  "op": "math.round",
  "value": <expression:Number>,
  "scale": <integer>,   // optional, static: the decimal places to keep, 0 to 28; default 0
  "mode": "<mode>"      // required, static
}
```

#### math.sub — expression

```jsonc
{ "op": "math.sub", "left": <expression:Number>, "right": <expression:Number> }
```

### Rulealize.Plugin.Binding 1.0.1

Namespace `bind`. Shorthand character `@`: a string that begins with it is this plugin's shorthand.
requires: { "plugin": "Rulealize.Plugin.Binding", "version": "^1.0" }
Specification: https://raw.githubusercontent.com/reny-develop/Rulealize.Plugin.Binding/main/doc/specification.md
Its package describes it: Scoped local bindings for Rulealize rule sets: bind.let and bind.local (the @ shorthand).

#### bind.let — expression

```jsonc
{
  "op": "bind.let",
  "bind": { "<name>": <expression>, … },     // the key set is static
  "in": <expression>
}
```

#### bind.local — expression

```jsonc
{ "op": "bind.local", "name": "<name>" }   // name is static
```

### Rulealize.Plugin.Branch 1.0.1

Namespace `branch`. No shorthand character.
requires: { "plugin": "Rulealize.Plugin.Branch", "version": "^1.0" }
Specification: https://raw.githubusercontent.com/reny-develop/Rulealize.Plugin.Branch/main/doc/specification.md
Its package describes it: Conditional branching for Rulealize rule sets: branch.if and branch.match.

#### branch.if — expression

```jsonc
{
  "op": "branch.if",
  "cond": <expression:Boolean>,
  "then": <expression>,
  "else": <expression>          // optional
}
```

#### branch.match — expression

```jsonc
{
  "op": "branch.match",
  "value": <expression>,
  "cases": { "<key>": <expression>, … },     // the keys are static
  "default": <expression>                    // optional
}
```

### Rulealize.Plugin.Chance 1.1.0

Namespace `chance`. No shorthand character.
requires: { "plugin": "Rulealize.Plugin.Chance", "version": "^1.1" }
Specification: https://raw.githubusercontent.com/reny-develop/Rulealize.Plugin.Chance/main/doc/specification.md
Its package describes it: Resolving what nobody chose in Rulealize rule sets: chance.pick, a weighted draw the runtime enumerates.

#### chance.pick — draw

```jsonc
{
  "op": "chance.pick",
  "of": <expression:Sequence>,
  "as": "<name>",            // optional
  "weight": <expression:Number>   // optional
}
```

#### chance.roll — draw

```jsonc
{ "op": "chance.roll", "faces": <expression:Number> }
```

### Rulealize.Plugin.Comparison 1.0.1

Namespace `cmp`. No shorthand character.
requires: { "plugin": "Rulealize.Plugin.Comparison", "version": "^1.0" }
Specification: https://raw.githubusercontent.com/reny-develop/Rulealize.Plugin.Comparison/main/doc/specification.md
Its package describes it: Equality, ordering and null tests for Rulealize rule sets: cmp.eq, cmp.lt, cmp.compare, cmp.isNull and friends.

#### cmp.coalesce — expression

```jsonc
{ "op": "cmp.coalesce", "of": [<expression>, …] }
```

#### cmp.compare — expression

```jsonc
{ "op": "cmp.compare", "left": <expression>, "right": <expression> }
```

#### cmp.eq — expression

```jsonc
{ "op": "cmp.eq", "left": <expression>, "right": <expression> }
```

#### cmp.gt — expression

```jsonc
{ "op": "cmp.gt", "left": <expression>, "right": <expression> }
```

#### cmp.gte — expression

```jsonc
{ "op": "cmp.gte", "left": <expression>, "right": <expression> }
```

#### cmp.isNull — expression

```jsonc
{ "op": "cmp.isNull", "value": <expression> }
```

#### cmp.lt — expression

```jsonc
{ "op": "cmp.lt", "left": <expression>, "right": <expression> }
```

#### cmp.lte — expression

```jsonc
{ "op": "cmp.lte", "left": <expression>, "right": <expression> }
```

#### cmp.ne — expression

```jsonc
{ "op": "cmp.ne", "left": <expression>, "right": <expression> }
```

### Rulealize.Plugin.Deck 1.0.0

Namespace `deck`. No shorthand character.
requires: { "plugin": "Rulealize.Plugin.Deck", "version": "^1.0" }
Specification: https://raw.githubusercontent.com/reny-develop/Rulealize.Plugin.Deck/main/doc/specification.md
Its package describes it: Piles of cards for Rulealize rule sets: deck.of, deck.deal, deck.move, deck.count, deck.cards.

#### deck.cards — expression

```jsonc
{ "op": "deck.cards", "of": <expression:pile> }
```

#### deck.count — expression

```jsonc
{ "op": "deck.count", "of": <expression:pile>, "card": <expression:Text> }
```

#### deck.size — expression

```jsonc
{ "op": "deck.size", "of": <expression:pile> }
```

#### deck.move — effect

```jsonc
{ "op": "deck.move", "from": <state field:pile>, "to": <state field:pile>, "card": <expression:Text>, "count": <expression:Number> }   // `count` optional
```

#### deck.of — schema

```jsonc
{ "op": "deck.of", "cards": ["<card>", …] }   // the cards are static
```

#### deck.draw — draw

```jsonc
{ "op": "deck.draw", "of": <expression:pile> }
```

### Rulealize.Plugin.Definition 1.0.1

Namespace `def`. Shorthand character `#`: a string that begins with it is this plugin's shorthand.
requires: { "plugin": "Rulealize.Plugin.Definition", "version": "^1.0" }
Specification: https://raw.githubusercontent.com/reny-develop/Rulealize.Plugin.Definition/main/doc/specification.md
Its package describes it: References and applications of a Rulealize rule set's definitions section: def.ref (the # shorthand) and def.call.

#### def.call — expression

```jsonc
{
  "op": "def.call",
  "def": "<name>",                       // static
  "args": { "<parameter>": <expression>, … }
}
```

#### def.ref — expression

```jsonc
{ "op": "def.ref", "name": "<name>" }   // name is static
```

### Rulealize.Plugin.Graph 1.0.1

Namespace `graph`. No shorthand character.
requires: { "plugin": "Rulealize.Plugin.Graph", "version": "^1.0" }
Specification: https://raw.githubusercontent.com/reny-develop/Rulealize.Plugin.Graph/main/doc/specification.md
Its package describes it: Graphs for Rulealize: a state field that is a fixed set of nodes and edges with a value at each node, and the operations to read one, walk it, and write to it.

#### graph.adjacent — expression

```jsonc
{
  "op": "graph.adjacent",
  "graph": <state field>,
  "node": <expression:Text>,
  "direction": "<direction>"   // optional, one of "out", "in", "either"; default "out"
}
```

#### graph.at — expression

```jsonc
{ "op": "graph.at", "graph": <state field>, "node": <expression:Text> }
```

#### graph.reachable — expression

```jsonc
{
  "op": "graph.reachable",
  "graph": <state field>,
  "from": <expression:Text>,
  "direction": "<direction>",   // optional, one of "out", "in", "either"; default "out"
  "as": "<name>",               // required with "through"
  "through": <expression:Boolean>   // optional
}
```

#### graph.set — effect

```jsonc
{
  "op": "graph.set",
  "target": <state field>,
  "node": <expression:Text>,
  "value": <expression>
}
```

#### graph.of — schema

```jsonc
{
  "op": "graph.of",
  "nodes": [ "<node>", … ],
  "edges": { "<node>": [ "<node>", … ], … },   // optional
  "directed": <boolean>,                        // optional, default false
  "value": <schema>
}
```

### Rulealize.Plugin.Grid 1.2.0

Namespace `grid`. No shorthand character.
requires: { "plugin": "Rulealize.Plugin.Grid", "version": "^1.2" }
Specification: https://raw.githubusercontent.com/reny-develop/Rulealize.Plugin.Grid/main/doc/specification.md
Its package describes it: Two-dimensional boards, coordinates, directions, ray traversal and functional board update for Rulealize rule sets.

#### grid.at — expression

```jsonc
{ "op": "grid.at", "grid": <expression:board>, "coord": <expression:coord> }
```

#### grid.cells — expression

```jsonc
{ "op": "grid.cells", "of": <expression:board> }
```

#### grid.coords — expression

```jsonc
{ "op": "grid.coords", "of": <expression:board> }
```

#### grid.directions — expression

```jsonc
{
  "op": "grid.directions",
  "of": <expression:board>,
  "kind": "<kind>"       // static
}
```

#### grid.ray — expression

```jsonc
{
  "op": "grid.ray",
  "grid": <expression:board>,
  "from": <expression:coord>,
  "dir": <expression:direction>,
  "length": <expression:Number>   // optional
}
```

#### grid.run — expression

```jsonc
{
  "op": "grid.run",
  "grid": <expression:board>,
  "from": <expression:coord>,
  "axis": <expression:direction>,
  "value": <expression>
}
```

#### grid.with — expression

```jsonc
{ "op": "grid.with",     "grid": <expression:board>, "coord": <expression:coord>,     "value": <expression> }
```

#### grid.withMany — expression

```jsonc
{ "op": "grid.withMany", "grid": <expression:board>, "coords": <expression:Sequence>, "value": <expression> }
```

#### grid.set — effect

```jsonc
{
  "op": "grid.set",
  "target": <state field:board>,
  "coord": <expression:coord>,
  "value": <expression>
}
```

#### grid.setMany — effect

```jsonc
{
  "op": "grid.setMany",
  "target": <state field:board>,
  "coords": <expression:Sequence>,
  "value": <expression>
}
```

#### grid.board — schema

```jsonc
{
  "op": "grid.board",
  "width": <integer>,        // static
  "height": <integer>,       // static
  "coord": "<notation>",     // static, "index" if omitted
  "cell": <schema node>      // static
}
```

#### grid.square — schema

```jsonc
{
  "op": "grid.square",
  "width": <integer>,
  "height": <integer>,
  "coord": "<notation>",   // optional, one of "index", "algebraic"; default "index"
  "nullable": <boolean>    // optional, default false
}
```

### Rulealize.Plugin.Logic 1.0.1

Namespace `logic`. No shorthand character.
requires: { "plugin": "Rulealize.Plugin.Logic", "version": "^1.0" }
Specification: https://raw.githubusercontent.com/reny-develop/Rulealize.Plugin.Logic/main/doc/specification.md
Its package describes it: Boolean operations for Rulealize rule sets: logic.and, logic.or, logic.not and logic.xor.

#### logic.and — expression

```jsonc
{ "op": "logic.and", "all": [<expression:Boolean>, …] }
```

#### logic.not — expression

```jsonc
{ "op": "logic.not", "value": <expression:Boolean> }
```

#### logic.or — expression

```jsonc
{ "op": "logic.or", "any": [<expression:Boolean>, …] }
```

#### logic.xor — expression

```jsonc
{ "op": "logic.xor", "of": [<expression:Boolean>, …] }
```

### Rulealize.Plugin.Record 1.0.1

Namespace `rec`. No shorthand character.
requires: { "plugin": "Rulealize.Plugin.Record", "version": "^1.0" }
Specification: https://raw.githubusercontent.com/reny-develop/Rulealize.Plugin.Record/main/doc/specification.md
Its package describes it: Records in Rulealize state: rec.of, rec.map, and the vocabulary for reading and writing a key that is computed rather than written down.

#### rec.at — expression

```jsonc
{ "op": "rec.at", "record": <expression>, "key": <expression:Text> }
```

#### rec.has — expression

```jsonc
{ "op": "rec.has", "record": <expression>, "key": <expression:Text> }
```

#### rec.keys — expression

```jsonc
{ "op": "rec.keys", "of": <expression> }
```

#### rec.with — expression

```jsonc
{ "op": "rec.with", "record": <expression>, "key": <expression>, "value": <expression> }
```

#### rec.set — effect

```jsonc
{ "op": "rec.set", "target": <state field>, "key": <expression>, "value": <expression> }
```

#### rec.update — effect

```jsonc
{ "op": "rec.update", "target": <state field>, "key": <expression>, "as": "<name>", "value": <expression> }
```

#### rec.map — schema

```jsonc
{ "op": "rec.map", "keys": ["<key>", …], "value": <schema> }
```

#### rec.of — schema

```jsonc
{ "op": "rec.of", "fields": { "<key>": <schema>, … } }
```

### Rulealize.Plugin.Secret 1.0.0

Namespace `secret`. No shorthand character.
requires: { "plugin": "Rulealize.Plugin.Secret", "version": "^1.0" }
Specification: https://raw.githubusercontent.com/reny-develop/Rulealize.Plugin.Secret/main/doc/specification.md
Its package describes it: Sealed values for Rulealize rule sets: choices that are made but not yet shown, which is what a simultaneous move needs.

#### secret.all — expression

```jsonc
{ "op": "secret.all", "of": <expression:sealed> }
```

#### secret.open — expression

```jsonc
{ "op": "secret.open", "of": <expression:sealed>, "owner": <expression:Text> }
```

#### secret.sealed — expression

```jsonc
{ "op": "secret.sealed", "of": <expression:sealed>, "owner": <expression:Text> }
```

#### secret.waiting — expression

```jsonc
{ "op": "secret.waiting", "of": <expression:sealed> }
```

#### secret.clear — effect

```jsonc
{ "op": "secret.clear", "target": <state field:sealed>, "owner": <expression:Text> }   // `owner` optional
```

#### secret.seal — effect

```jsonc
{ "op": "secret.seal", "target": <state field:sealed>, "owner": <expression:Text>, "value": <expression> }
```

#### secret.of — schema

```jsonc
{ "op": "secret.of", "owners": ["<owner>", …], "value": <schema> }   // the owners are static
```

### Rulealize.Plugin.Sequence 1.5.0

Namespace `seq`. No shorthand character.
requires: { "plugin": "Rulealize.Plugin.Sequence", "version": "^1.5" }
Specification: https://raw.githubusercontent.com/reny-develop/Rulealize.Plugin.Sequence/main/doc/specification.md
Its package describes it: Generation, transformation and aggregation over Rulealize sequences: seq.of, seq.range, seq.any, seq.count, seq.takeWhile, seq.selectMany, seq.replaceAt, seq.scan and friends.

#### seq.any — expression

```jsonc
{
  "op": "seq.any",
  "source": <expression:Sequence>,
  "as": "<name>",              // optional
  "predicate": <expression:Boolean>   // optional
}
```

#### seq.concat — expression

```jsonc
{ "op": "seq.concat", "of": [ <expression:Sequence>, … ] }
```

#### seq.count — expression

```jsonc
{
  "op": "seq.count",
  "source": <expression:Sequence>,
  "as": "<name>",          // optional
  "where": <expression:Boolean>   // optional
}
```

#### seq.elementAt — expression

```jsonc
{
  "op": "seq.elementAt",
  "source": <expression:Sequence>,
  "index": <expression:Number>
}
```

#### seq.empty — expression

```jsonc
{ "op": "seq.empty" }
```

#### seq.of — expression

```jsonc
{ "op": "seq.of", "of": [ <expression>, … ] }
```

#### seq.range — expression

```jsonc
{ "op": "seq.range", "from": <expression:Number>, "count": <expression:Number> }
```

#### seq.replaceAt — expression

```jsonc
{
  "op": "seq.replaceAt",
  "source": <expression:Sequence>,
  "index": <expression:Number>,
  "as": "<name>",            // optional
  "value": <expression>
}
```

#### seq.scan — expression

```jsonc
{
  "op": "seq.scan",
  "source": <expression:Sequence>,
  "as": "<name>",            // optional: the element
  "seed": <expression>,      // what the first step starts from
  "acc": "<name>",           // what the step before made
  "next": <expression>       // what this step makes, reading both
}
```

#### seq.select — expression

```jsonc
{ "op": "seq.select", "source": <expression:Sequence>, "as": "<name>", "select": <expression> }
```

#### seq.selectMany — expression

```jsonc
{
  "op": "seq.selectMany",
  "source": <expression:Sequence>,
  "as": "<name>",
  "select": <expression:Sequence>
}
```

#### seq.skip — expression

```jsonc
{ "op": "seq.skip", "source": <expression:Sequence>, "count": <expression:Number> }
```

#### seq.sum — expression

```jsonc
{
  "op": "seq.sum",
  "source": <expression:Sequence>,
  "as": "<name>",            // optional
  "select": <expression:Number>   // optional
}
```

#### seq.take — expression

```jsonc
{ "op": "seq.take", "source": <expression:Sequence>, "count": <expression:Number> }
```

#### seq.takeWhile — expression

```jsonc
{
  "op": "seq.takeWhile",
  "source": <expression:Sequence>,
  "as": "<name>",
  "predicate": <expression:Boolean>
}
```

#### seq.where — expression

```jsonc
{ "op": "seq.where",  "source": <expression:Sequence>, "as": "<name>", "predicate": <expression:Boolean> }
```

### Rulealize.Plugin.SqliteStore 1.0.0

Namespace `sqlite`. No shorthand character.
requires: { "plugin": "Rulealize.Plugin.SqliteStore", "version": "^1.0" }
Specification: https://raw.githubusercontent.com/reny-develop/Rulealize.Plugin.SqliteStore/main/doc/specification.md
Its package describes it: A store for a Rulealize rule set that keeps instances: every state document in one SQLite table, each with a version, so that two transitions that raced are told apart on commit and a position is where it was when the process starts again.

It registers no operations.

### Rulealize.Plugin.State 1.0.1

Namespace `state`. Shorthand character `$`: a string that begins with it is this plugin's shorthand.
requires: { "plugin": "Rulealize.Plugin.State", "version": "^1.0" }
Specification: https://raw.githubusercontent.com/reny-develop/Rulealize.Plugin.State/main/doc/specification.md
Its package describes it: Reading and writing a Rulealize rule set's state: state.get (the $ shorthand), state.set and state.update.

#### state.get — expression

```jsonc
{ "op": "state.get", "path": "<path>" }   // path is static
```

#### state.set — effect

```jsonc
{ "op": "state.set", "path": "<path>", "value": <expression> }   // path is static
```

#### state.update — effect

```jsonc
{
  "op": "state.update",
  "path": "<path>",     // static
  "as": "<name>",       // static
  "value": <expression>
}
```

### Rulealize.Plugin.Text 1.0.0

Namespace `str`. No shorthand character.
requires: { "plugin": "Rulealize.Plugin.Text", "version": "^1.0" }
Specification: https://raw.githubusercontent.com/reny-develop/Rulealize.Plugin.Text/main/doc/specification.md
Its package describes it: Questions about text for a Rulealize rule set, the same on every runtime: str.trim, str.length, str.contains, str.startsWith, str.endsWith, str.slice and str.only, which checks every character against fixed classes such as asciiDigit and katakana. No regular expressions.

#### str.contains — expression

```jsonc
{ "op": "str.contains",   "value": <expression:Text>, "part": <expression:Text> }
```

#### str.endsWith — expression

```jsonc
{ "op": "str.endsWith",   "value": <expression:Text>, "part": <expression:Text> }
```

#### str.length — expression

```jsonc
{ "op": "str.length", "value": <expression:Text> }
```

#### str.only — expression

```jsonc
{ "op": "str.only", "value": <expression:Text>, "of": ["<class>", …] }
```

#### str.slice — expression

```jsonc
{ "op": "str.slice", "value": <expression:Text>, "from": <expression:Number>, "count": <expression:Number> }
```

#### str.startsWith — expression

```jsonc
{ "op": "str.startsWith", "value": <expression:Text>, "part": <expression:Text> }
```

#### str.trim — expression

```jsonc
{ "op": "str.trim", "value": <expression:Text> }
```

### Rulealize.Plugin.Tuple 1.0.1

Namespace `tuple`. No shorthand character.
requires: { "plugin": "Rulealize.Plugin.Tuple", "version": "^1.0" }
Specification: https://raw.githubusercontent.com/reny-develop/Rulealize.Plugin.Tuple/main/doc/specification.md
Its package describes it: Compound values for Rulealize rule sets: tuple.of and tuple.at, so that several values can travel through an input argument as one.

#### tuple.at — expression

```jsonc
{ "op": "tuple.at", "tuple": <expression>, "index": <integer> }
```

#### tuple.of — expression

```jsonc
{ "op": "tuple.of", "of": [ <expression>, … ] }
```

### Rulealize.Plugin.TypeSchema 1.3.0

Namespace `type`. No shorthand character.
requires: { "plugin": "Rulealize.Plugin.TypeSchema", "version": "^1.3" }
Specification: https://raw.githubusercontent.com/reny-develop/Rulealize.Plugin.TypeSchema/main/doc/specification.md
Its package describes it: Schema vocabulary for a Rulealize rule set's state.schema: type.enum, type.int, type.decimal, type.bool, type.string and type.list.

#### type.bool — schema

```jsonc
{ "op": "type.bool", "nullable": <boolean> }
```

#### type.decimal — schema

```jsonc
{
  "op": "type.decimal",
  "scale": <integer>,     // optional, static: the most decimal places, 0 to 28
  "min": <number>,        // optional, static
  "max": <number>,        // optional, static
  "nullable": <boolean>   // optional
}
```

#### type.enum — schema

```jsonc
{
  "op": "type.enum",
  "values": ["<value>", …],     // static
  "nullable": <boolean>         // optional
}
```

#### type.int — schema

```jsonc
{
  "op": "type.int",
  "min": <integer>,       // optional, static
  "max": <integer>,       // optional, static
  "nullable": <boolean>   // optional
}
```

#### type.list — schema

```jsonc
{
  "op": "type.list",
  "element": <schema node>,      // required
  "minLength": <integer>,        // optional, static
  "maxLength": <integer>         // optional, static
}
```

#### type.string — schema

```jsonc
{
  "op": "type.string",
  "minLength": <integer>,   // optional, static
  "maxLength": <integer>,   // optional, static
  "nullable": <boolean>     // optional
}
```

## Published rule sets

A published rule set is held by naming it in a document's `uses`, as the line given under
it. `as` is the name the holding document calls it by: it may not contain a `.`, and it is
what qualifies the held rule set's inputs there — `quota.consume`, never the identifier
written out.

### Rulealize.RuleSet.Budget 1.0.0

uses: { "ruleSet": "Rulealize.RuleSet.Budget", "version": "^1.0", "as": "budget" }
Inputs, as a holder writes them: `budget.budget`, `budget.clear`, `budget.remove`, `budget.spend`
Requires: Rulealize.Plugin.TypeSchema ^1.3, Rulealize.Plugin.State ^1.0, Rulealize.Plugin.Sequence ^1.4, Rulealize.Plugin.Record ^1.0, Rulealize.Plugin.Comparison ^1.0, Rulealize.Plugin.Logic ^1.0, Rulealize.Plugin.Arithmetic ^1.0, Rulealize.Plugin.Branch ^1.0, Rulealize.Plugin.Binding ^1.0, Rulealize.Plugin.Definition ^1.0, Rulealize.Plugin.Text ^1.0
Its package describes it: A household budget for a month: what was spent, on which day and in which category, against the month's budget. A Rulealize rule set.

### Rulealize.RuleSet.Calculator 1.0.0

uses: { "ruleSet": "Rulealize.RuleSet.Calculator", "version": "^1.0", "as": "calculator" }
Inputs, as a holder writes them: `calculator.press`
Requires: Rulealize.Plugin.TypeSchema ^1.3, Rulealize.Plugin.State ^1.0, Rulealize.Plugin.Grid ^1.0, Rulealize.Plugin.Sequence ^1.5, Rulealize.Plugin.Record ^1.0, Rulealize.Plugin.Comparison ^1.0, Rulealize.Plugin.Logic ^1.0, Rulealize.Plugin.Arithmetic ^1.2, Rulealize.Plugin.Branch ^1.0, Rulealize.Plugin.Binding ^1.0, Rulealize.Plugin.Definition ^1.0
Its package describes it: A scientific calculator: brackets, powers, sin, cos and tan in degrees or radians, logarithms, and the keys laid out as one. A Rulealize rule set.

### Rulealize.RuleSet.Checklist 1.0.0

uses: { "ruleSet": "Rulealize.RuleSet.Checklist", "version": "^1.0", "as": "checklist" }
Inputs, as a holder writes them: `checklist.complete`
Requires: Rulealize.Plugin.TypeSchema ^1.0, Rulealize.Plugin.State ^1.0, Rulealize.Plugin.Comparison ^1.0, Rulealize.Plugin.Logic ^1.0, Rulealize.Plugin.Binding ^1.0, Rulealize.Plugin.Definition ^1.0, Rulealize.Plugin.Sequence ^1.0
Its package describes it: Named steps, each done once, and an ending when none are left. A Rulealize rule set written to be held.

### Rulealize.RuleSet.Chess 1.0.0

uses: { "ruleSet": "Rulealize.RuleSet.Chess", "version": "^1.0", "as": "chess" }
Inputs, as a holder writes them: `chess.move`
Requires: Rulealize.Plugin.Binding ^1.0, Rulealize.Plugin.Branch ^1.0, Rulealize.Plugin.Definition ^1.0, Rulealize.Plugin.Logic ^1.0, Rulealize.Plugin.Comparison ^1.0, Rulealize.Plugin.Arithmetic ^1.0, Rulealize.Plugin.TypeSchema ^1.0, Rulealize.Plugin.Sequence ^1.1, Rulealize.Plugin.State ^1.0, Rulealize.Plugin.Grid ^1.1, Rulealize.Plugin.Tuple ^1.0
Its package describes it: Chess, with castling, en passant and promotion. A Rulealize rule set.

### Rulealize.RuleSet.Exchange 1.0.0

uses: { "ruleSet": "Rulealize.RuleSet.Exchange", "version": "^1.0", "as": "exchange" }
Inputs, as a holder writes them: `exchange.ours.confirm`, `exchange.ours.offer`, `exchange.ours.withdraw`, `exchange.theirs.confirm`, `exchange.theirs.offer`, `exchange.theirs.withdraw`
Holds: Rulealize.RuleSet.Exchange.Side ^1.0 as `ours`, Rulealize.RuleSet.Exchange.Side ^1.0 as `theirs`
Requires: Rulealize.Plugin.State ^1.0, Rulealize.Plugin.Comparison ^1.0, Rulealize.Plugin.Record ^1.0, Rulealize.Plugin.Logic ^1.0
Its package describes it: Two parties, each offering something, and neither committed until both are. A Rulealize rule set, shipped with the half it is built from.

### Rulealize.RuleSet.Minesweeper 1.0.0

uses: { "ruleSet": "Rulealize.RuleSet.Minesweeper", "version": "^1.0", "as": "minesweeper" }
Inputs, as a holder writes them: `minesweeper.digs`, `minesweeper.flags`, `minesweeper.tap`
Requires: Rulealize.Plugin.TypeSchema ^1.0, Rulealize.Plugin.State ^1.0, Rulealize.Plugin.Sequence ^1.2, Rulealize.Plugin.Comparison ^1.0, Rulealize.Plugin.Logic ^1.0, Rulealize.Plugin.Arithmetic ^1.0, Rulealize.Plugin.Branch ^1.0, Rulealize.Plugin.Binding ^1.0, Rulealize.Plugin.Definition ^1.0, Rulealize.Plugin.Grid ^1.1, Rulealize.Plugin.Graph ^1.0, Rulealize.Plugin.Chance ^1.1
Its package describes it: Minesweeper on a 9 × 9 board with ten mines, laid after the first cell is opened and never next to it. A Rulealize rule set.

### Rulealize.RuleSet.PackingList 1.1.0

uses: { "ruleSet": "Rulealize.RuleSet.PackingList", "version": "^1.1", "as": "packinglist" }
Inputs, as a holder writes them: `packinglist.add`, `packinglist.pack`, `packinglist.remove`, `packinglist.unpack`
Requires: Rulealize.Plugin.TypeSchema ^1.0, Rulealize.Plugin.State ^1.0, Rulealize.Plugin.Sequence ^1.2, Rulealize.Plugin.Comparison ^1.0, Rulealize.Plugin.Logic ^1.0, Rulealize.Plugin.Binding ^1.0, Rulealize.Plugin.Branch ^1.0, Rulealize.Plugin.Definition ^1.0
Its package describes it: What to take, and what is in the bag already: items added as they come to mind and ticked as they are packed. A Rulealize rule set.

### Rulealize.RuleSet.Quota 1.0.0

uses: { "ruleSet": "Rulealize.RuleSet.Quota", "version": "^1.0", "as": "quota" }
Inputs, as a holder writes them: `quota.consume`, `quota.reset`
Requires: Rulealize.Plugin.TypeSchema ^1.0, Rulealize.Plugin.State ^1.0, Rulealize.Plugin.Comparison ^1.0, Rulealize.Plugin.Arithmetic ^1.0
Its package describes it: A bounded allowance: so many of something, and then no more. A Rulealize rule set written to be held.

### Rulealize.RuleSet.Request 1.1.0

uses: { "ruleSet": "Rulealize.RuleSet.Request", "version": "^1.1", "as": "request" }
Inputs, as a holder writes them: `request.deny`, `request.grant`, `request.raise`
Requires: Rulealize.Plugin.TypeSchema ^1.0, Rulealize.Plugin.State ^1.0, Rulealize.Plugin.Comparison ^1.0, Rulealize.Plugin.Logic ^1.0, Rulealize.Plugin.Binding ^1.0
Its package describes it: One request, raised over something and then granted or denied. A Rulealize rule set written to be held.

### Rulealize.RuleSet.Reversi 1.0.0

uses: { "ruleSet": "Rulealize.RuleSet.Reversi", "version": "^1.0", "as": "reversi" }
Inputs, as a holder writes them: `reversi.pass`, `reversi.place`
Requires: Rulealize.Plugin.Binding ^1.0, Rulealize.Plugin.Branch ^1.0, Rulealize.Plugin.Definition ^1.0, Rulealize.Plugin.Logic ^1.0, Rulealize.Plugin.Comparison ^1.0, Rulealize.Plugin.Arithmetic ^1.0, Rulealize.Plugin.TypeSchema ^1.0, Rulealize.Plugin.Sequence ^1.0, Rulealize.Plugin.State ^1.0, Rulealize.Plugin.Grid ^1.0
Its package describes it: Reversi for two players on an 8 × 8 board, with passing when no disc can be placed. A Rulealize rule set.

### Rulealize.RuleSet.Scoreboard 1.0.0

uses: { "ruleSet": "Rulealize.RuleSet.Scoreboard", "version": "^1.0", "as": "scoreboard" }
Inputs, as a holder writes them: `scoreboard.clear`, `scoreboard.join`, `scoreboard.leave`, `scoreboard.rename`, `scoreboard.score`, `scoreboard.undo`
Requires: Rulealize.Plugin.TypeSchema ^1.0, Rulealize.Plugin.State ^1.0, Rulealize.Plugin.Sequence ^1.3, Rulealize.Plugin.Record ^1.0, Rulealize.Plugin.Comparison ^1.0, Rulealize.Plugin.Logic ^1.0, Rulealize.Plugin.Arithmetic ^1.0, Rulealize.Plugin.Branch ^1.0, Rulealize.Plugin.Binding ^1.0, Rulealize.Plugin.Definition ^1.0
Its package describes it: Points for each player, round after round, and who is ahead. A Rulealize rule set.

### Rulealize.RuleSet.Signatures 1.1.0

uses: { "ruleSet": "Rulealize.RuleSet.Signatures", "version": "^1.1", "as": "signatures" }
Inputs, as a holder writes them: `signatures.decline`, `signatures.sign`
Requires: Rulealize.Plugin.TypeSchema ^1.0, Rulealize.Plugin.State ^1.0, Rulealize.Plugin.Comparison ^1.0, Rulealize.Plugin.Logic ^1.0, Rulealize.Plugin.Binding ^1.0, Rulealize.Plugin.Branch ^1.0, Rulealize.Plugin.Definition ^1.0, Rulealize.Plugin.Arithmetic ^1.0, Rulealize.Plugin.Sequence ^1.0
Its package describes it: A decision that needs several signatures before it counts. A Rulealize rule set written to be held.

### Rulealize.RuleSet.SignedRequest 1.1.0

uses: { "ruleSet": "Rulealize.RuleSet.SignedRequest", "version": "^1.1", "as": "signedrequest" }
Inputs, as a holder writes them: `signedrequest.req.deny`, `signedrequest.req.grant`, `signedrequest.req.raise`, `signedrequest.sigs.decline`, `signedrequest.sigs.sign`
Holds: Rulealize.RuleSet.Request ^1.1 as `req`, Rulealize.RuleSet.Signatures ^1.1 as `sigs`
Requires: Rulealize.Plugin.State ^1.0, Rulealize.Plugin.Comparison ^1.0, Rulealize.Plugin.Record ^1.0, Rulealize.Plugin.Logic ^1.0
Its package describes it: A request that may not be granted until enough people have signed it. A Rulealize rule set, composed of two others.

### Rulealize.RuleSet.SplitBill 1.0.0

uses: { "ruleSet": "Rulealize.RuleSet.SplitBill", "version": "^1.0", "as": "splitbill" }
Inputs, as a holder writes them: `splitbill.clear`, `splitbill.join`, `splitbill.leave`, `splitbill.pay`, `splitbill.rename`, `splitbill.undo`
Requires: Rulealize.Plugin.TypeSchema ^1.0, Rulealize.Plugin.State ^1.0, Rulealize.Plugin.Sequence ^1.3, Rulealize.Plugin.Record ^1.0, Rulealize.Plugin.Comparison ^1.0, Rulealize.Plugin.Logic ^1.0, Rulealize.Plugin.Arithmetic ^1.1, Rulealize.Plugin.Branch ^1.0, Rulealize.Plugin.Binding ^1.0, Rulealize.Plugin.Definition ^1.0
Its package describes it: Who paid for what on a trip or a night out, and what each one pays or gets back when the total is shared equally. A Rulealize rule set.

### Rulealize.RuleSet.WeightLog 1.0.0

uses: { "ruleSet": "Rulealize.RuleSet.WeightLog", "version": "^1.0", "as": "weightlog" }
Inputs, as a holder writes them: `weightlog.goal`, `weightlog.record`, `weightlog.remove`
Requires: Rulealize.Plugin.TypeSchema ^1.3, Rulealize.Plugin.State ^1.0, Rulealize.Plugin.Sequence ^1.2, Rulealize.Plugin.Record ^1.0, Rulealize.Plugin.Comparison ^1.0, Rulealize.Plugin.Logic ^1.0, Rulealize.Plugin.Arithmetic ^1.0, Rulealize.Plugin.Branch ^1.0, Rulealize.Plugin.Binding ^1.0, Rulealize.Plugin.Definition ^1.0, Rulealize.Plugin.Text ^1.0
Its package describes it: A weight diary: one line a day, with how the day felt and whether there was exercise, against a goal. A Rulealize rule set.