@jarenjs/flow 0.72.3 → 0.75.0

package/docs/STATECHART-FORMAT.md

@@ -0,0 +1,186 @@
+# Jaren statecharts — jaren-fsm 0.2
+
+`compileStatechart` compiles a JSON document into pure `start`, `step` and
+`advance` functions. It provides compound states, parallel regions, shallow
+and deep history, completion/eventless transitions and delayed transitions.
+It executes no effect and reads no clock. `compileFsm`, `createFsmSession`,
+`fsmToApp` and the 0.1 schemas retain their existing contracts.
+
+The canonical grammar is [jaren-statechart.schema.json](../schemas/jaren-statechart.schema.json)
+(`https://jarenjs.dev/schemas/jaren-fsm/0.2`), with draft-07 and authoring twins.
+Register the query grammar when validating. Compilation checks references,
+hierarchy and transition domains that JSON Schema cannot prove. Unknown
+statechart, state and transition members are compile errors.
+
+## 1. Document and state tree
+
+```json
+{
+  "$fsm": "0.2",
+  "initial": "working",
+  "states": [
+    { "id": "working", "initial": "editing" },
+    { "id": "editing", "parent": "working" },
+    { "id": "review", "parent": "working" },
+    { "id": "memory", "parent": "working", "history": "deep" },
+    "paused",
+    { "id": "expired", "final": true }
+  ],
+  "transitions": [
+    { "from": "editing", "event": "submit", "to": "review" },
+    { "from": "working", "event": "pause", "to": "paused" },
+    { "from": "paused", "event": "resume", "to": "memory" },
+    { "from": "review", "after": 60000, "to": "expired" }
+  ]
+}
+```
+
+States have globally unique, nonempty string ids. A bare string declares an
+atomic state. An object supports `id`, `parent`, `initial`, `type`, `history`,
+`final`, `entry` and `exit`. The parent relation MUST be acyclic.
+
+| Type | Contract |
+|---|---|
+| `atomic` | No children. The default when no ordinary children exist. |
+| `compound` | Exactly one ordinary child active; `initial` MUST name an immediate ordinary child. Inferred when ordinary children exist. |
+| `parallel` | All ordinary children active. Each region recursively enters its initial configuration. No `initial` on the parallel state itself. |
+| `final` | No children or outgoing transitions. `final: true` is shorthand. |
+| `history` | A pseudo-state with a parent and `history: "shallow"` or `"deep"`; no children, outgoing transitions or effects. `history` infers this type. |
+
+The document's `initial` MUST name an ordinary root state. State effects use
+FLOW-FORMAT's `{run,with?}` descriptors. Final and history declarations cannot
+conflict with an explicit `type`. Parents precede children in runtime tree
+order even if the flattened declarations list a child first; siblings retain
+declaration order.
+
+Entering a compound target recursively enters its initial child. Entering a
+parallel target recursively enters every region. An explicit descendant target
+enters its ancestors and fills any unmentioned parallel regions with defaults.
+
+## 2. Selection, effects and completion
+
+A transition supports `from`, `to`, `guard`, `effects`, `type` and at most one
+trigger: `event`, `after`, `always: true` or `done: true`. An absent or null
+event is a wildcard over **external string events**, as in 0.1. It does not
+match timers or completion. A transition MUST name declared endpoints.
+
+For each active leaf, search its own transitions first, then its ancestors
+nearest first. Within a source, document order decides; a wildcard before a
+named transition wins. Evaluate a shared ancestor guard once per microstep.
+Independent parallel regions can transition in the same step. Conflicting
+exit sets are resolved in favor of the descendant source; unrelated conflicts
+use tree order of the selecting leaves. The selected transition effects run
+in transition document order.
+
+`type: "external"` is the default in **0.2**, including self-transitions.
+Its domain is the least common **proper compound ancestor** of source and
+target (or the virtual root); a parallel ancestor is not such a domain.
+Exiting that domain's active descendants makes a cross-region transition
+leave and re-enter the parallel state, restoring untargeted regions to their
+defaults. `type: "internal"` can target the source or its descendants: the
+source stays entered, while its active descendants exit. An atomic internal
+self-transition therefore runs only its transition effects. This is an
+explicit version difference from 0.1's implicit internal self-transition.
+
+Each microstep resolves effects against its pre-transition scope in order:
+exit effects in reverse tree order, transition effects in document order,
+entry effects in tree order. `$.state` is the ordered **array of active leaf
+ids**; `$.event` is the external name, or null for initial entry/timers;
+`$.payload` and `$.context` are caller values, defaulting to null. Guards
+use query effective boolean value. Evaluation failures retain FLOW-FORMAT's
+JF2003/JF2004 records and fail-closed behavior.
+
+`always` transitions participate in automatic stabilization after initial
+entry, an external event or a timer. `done` is enabled when its compound
+source has an active immediate final child, or all regions of its parallel
+source have completed. Completion sources MUST be compound/parallel. A
+completed root reports `final: true`; it is still possible to send events to
+that root's ancestors/sources until the host chooses to stop. There is no
+implicit context assignment, raised-event queue or invocation machinery.
+
+`maxMicrosteps` (default 1000, positive safe integer) bounds one call's
+automatic transitions and timer processing. Exhaustion throws JF2012; pure
+inputs and session state remain unchanged. There is no partial-result commit.
+These rules borrow hierarchy/history and transition-domain definitions from
+[SCXML's control semantics](https://www.w3.org/TR/scxml/), but this JSON format
+is not an SCXML implementation or an SCXML conformance claim.
+
+## 3. History
+
+Immediately before exiting a compound/parallel state, remember its active
+configuration for each declared history child. Shallow history stores the
+active immediate ordinary children; re-entry initializes their descendants.
+Deep history stores active atomic/final leaves, including all parallel
+regions, and restores those leaves. Targeting history before any record exists
+uses the parent's default initial configuration. Entering the parent normally
+uses its defaults even if history was recorded; history is an explicit target.
+
+History restores **control**, not elapsed timers or host context. Restored
+states run their entry effects and schedule fresh delays. A timer that belonged
+to an exited state remains cancelled.
+
+## 4. Time is input
+
+```js
+const chart = compileStatechart(doc);
+const initial = chart.start({ now: 1000, context });
+const next = chart.step(initial.state, 'submit', { now: 1200, context });
+const later = chart.advance(next.state, 61200, { context });
+```
+
+`now` is a finite number in the host's millisecond time domain; fresh starts
+default to zero. Omitted step time preserves the snapshot's time. Time MUST
+NOT move backwards (JF2011). The engine never calls `Date.now`, starts a host
+timer, or waits. A host may arm a timer from the earliest returned deadline
+and call `advance` when notified, including after process restart.
+
+`after` is a finite nonnegative duration. Entry creates one timer per delayed
+transition, storing its absolute deadline, transition index and monotonically
+increasing token. Exit cancels the source's timers. A timer is consumed once,
+even if its guard is false. Equal deadlines use transition order. Newly entered
+delays use logical firing time, not the time the host eventually delivered the
+wake-up. Overflowing deadlines/tokens are JF2011.
+
+`step` does not implicitly fire overdue timers. The host chooses whether an
+external event or a due timer happens first. `advance` consumes due timers up
+to its supplied time and stabilizes after each. `{one: true}` consumes at most
+one timer plus its stabilization, leaving time at that logical firing instant;
+when none is due it advances to the requested time. The composition bridge
+uses this mode to persist visit counts between timer deliveries. Timer indices
+cannot be forged as string events: external dispatch and time advancement are
+separate APIs.
+
+## 5. Snapshot and session
+
+`StatechartState` is the whole control snapshot:
+
+```jsonc
+{
+  "active": ["review"],
+  "history": { "memory": ["review"] },
+  "timers": [{ "transition": 3, "at": 61200, "token": 1 }],
+  "serial": 1,
+  "time": 1200
+}
+```
+
+Snapshots are frozen JSON. `restore(snapshot)` validates legal active and
+history configurations, timer sources/deadlines/tokens and numeric counters;
+it normalizes leaf/history/timer ordering and returns an independent frozen
+copy. Invalid snapshots are JF2010. A snapshot's schema is
+[jaren-statechart-state.schema.json](../schemas/jaren-statechart-state.schema.json).
+Standalone callers bind snapshots to their machine revision; composed workflows
+perform that comparison themselves.
+
+Results carry `changed`, `state`, `final`, `effects`, `errors`, `entered`,
+`exited` and `transitions` (indices into the compiled document). `changed`
+means a transition fired. An ignored event or a consumed false timer can still
+advance snapshot time, so persist the returned state even when `changed` is false.
+
+`createStatechartSession(chart, {state?, now?, context?, store?})` exposes
+`state`, `done`, `initial`, `send`, `advance` and `can`. `initial` contains entry
+effects for a fresh start and is null when restoring; the host executes these
+and later result effects. Optional synchronous `store.load()`/`store.save(state)`
+persist a fresh initial state and every successful send/advance **before** the
+session advances. A failed save leaves the session unchanged. Async stores
+belong at the workflow boundary. `can` is a pure dry run with no store write.

package/docs/WORKFLOW-FORMAT.md

@@ -0,0 +1,260 @@
+# Composed workflows — jaren-workflow 0.2
+
+`compileWorkflow(document, {tasks, store?})` lowers a neutral JSON workflow
+onto `compileStatechart` and `compileDag`. The statechart chooses control;
+the DAG executor owns dependency scheduling, fan-out/fan-in and task abort.
+The bridge transfers results, persists snapshots and dispatches completion.
+Host roles, prompts, model settings, network clients and tools remain in the
+versioned task registry.
+
+The composed format uses `$workflow: "0.2"` and schema id
+`https://jarenjs.dev/schemas/jaren-workflow/0.2`. This deliberately avoids
+reusing Mermaid's historical `jaren-workflow/0.1` schema identity, which denotes
+the unversioned flat-FSM projection. The new schema is
+[jaren-workflow.schema.json](../schemas/jaren-workflow.schema.json), with
+draft-07 and derived authoring twins. Register the DAG, query and JSLT grammars
+for full validation; schema acceptance is followed by compilation.
+
+## 1. The document
+
+```json
+{
+  "$workflow": "0.2",
+  "revision": "review/1",
+  "initial": "prepare",
+  "states": {
+    "prepare": {
+      "work": { "task": "prepare", "version": "1" },
+      "then": "check",
+      "limit": 3
+    },
+    "check": {
+      "choose": [{ "guard": "$.context.data.ready", "to": "review" }],
+      "otherwise": "prepare"
+    },
+    "review": {
+      "on": [
+        { "event": "approve", "guard": "$.payload.accept", "to": "done" },
+        { "event": "retry", "to": "prepare" }
+      ],
+      "after": { "ms": 60000, "to": "expired" }
+    },
+    "done": { "final": true },
+    "expired": { "final": true }
+  }
+}
+```
+
+`revision` is a nonblank host-declared revision. `initial` names a state in
+`states`, a nonempty object keyed by nonempty ids. References are local to
+that object. Each state declares exactly one form; unknown members refuse.
+
+| Form | Members and meaning |
+|---|---|
+| Work | `work: {task, version, with?}` or `work: {dag: <jaren-dag document>}`; `then` required, `input` and `catch` optional. |
+| Choice | `choose: [{guard,to}, …]` and `otherwise`; first true guard wins. |
+| Wait | `on: [{event,to,guard?}, …]`; optional `after: {ms,to}`. At least one event or delay is required. |
+| Nested flow | `flow: {initial,states}` and `then`; a compound state whose child final completes it. |
+| Final | `final: true`; ends its scope and returns its current data. |
+
+Every state may declare `limit`, a positive safe integer. It bounds total
+entries to that fully qualified state **for the whole run**, including
+re-entries through an external event or nested flow. A loop is a back-edge in
+the control graph. Compilation proves that every automatically traversable
+cycle crosses a limited state; otherwise it rejects with JF0022. External
+event edges do not advance themselves and are excluded from this proof.
+Timer edges ARE automatic. Runtime admission counts all entered states and
+rejects an excess with JF2015 before starting work in them. Nested depth is
+bounded at 64. An exhausted bound is an error, not successful completion.
+
+Static concurrent branches belong inside `work.dag`, using its existing port,
+query, stylesheet and task vocabulary. Parallel statechart regions are available
+through `compileStatechart`; a composed workflow's dynamic control intentionally
+has one active leaf and one pending work region. Nested control composes by
+lowering; it does not start a second workflow scheduler.
+
+## 2. Scope, data and errors
+
+Guards and a work state's `input` query read
+`{state,event,payload,context}`. `state` is the active-leaf array. Context is:
+
+- `input`: the original run input, unchanged across the workflow;
+- `data`: the current value, initially the input and replaced after each work;
+- `event`: the last accepted external `{type,payload?}` event, initially null;
+- `results`: the latest completed work result by qualified state id;
+- `visits`: entry counts by qualified state id.
+
+The default work input is `$.context.data`. A custom `input` query also sees
+`$.context.activation = {runId,state,visit,key}`. `key` is the canonical JSON
+encoding of `[runId, qualifiedStateId, visit]`; it remains the same after a
+crash/resume and differs between loop iterations. For an effectful task, pass
+it explicitly with the work input and have the external system deduplicate it:
+
+```jsonc
+{
+  "work": { "task": "charge", "version": "billing/3",
+    "with": { "idempotencyKey": "$.key", "order": "$.data" } },
+  "input": { "key": "$.context.activation.key", "data": "$.context.data" },
+  "then": "done"
+}
+```
+
+A task handler has the existing DAG signature `({with,input}, signal)`.
+`work.with` reads the **DAG input**, not the outer control scope. Missing
+query results become null. Work inputs, outputs and snapshots must survive
+canonical JSON serialization. Snapshot ownership is separate from task-owned
+values; restoring a checkpoint does not hand a task mutable durable state.
+
+On success, the bridge records the result, replaces `data`, clears pending
+work and sends the lowered completion event. A `catch` target handles JF2006
+node failures by replacing data with `{error:{code,message,nodeId}}` and
+transitioning there. Store, provenance, cancellation and visit-bound errors
+are never swallowed by `catch`. Uncaught task failures reject; persisted
+checkpoints remain available for a later retry.
+
+Unlike a standalone statechart, a workflow rejects a guard evaluation error
+as JF2016 before advancing control: choosing a fallback after a broken work
+predicate is not a successful workflow decision. The lower-level diagnostic
+path remains on the error. Task effects are at-least-once across crash windows;
+checkpointing does not make an external service exactly-once. Implementation
+versions remain host declarations: the compiler cannot detect code changes
+hidden behind an unchanged version token.
+
+## 3. Deterministic lowering
+
+`lowerWorkflow(document)` returns frozen JSON containing the original
+`document`, lowering `version`, declared `revision`, `fsm`, `dags`, `specs` and
+`sources`. It resolves no host handler and performs no work. Each state gets
+a stable JSON Pointer id, for example `/states/prepare` or
+`/states/round/flow/states/prepare`; each id segment escapes `~` and `/`.
+
+Work shorthand lowers to input → versioned checkpointed task → checkpointed
+output. Inline DAGs retain their wiring and checkpoint declarations, with
+the output checkpoint enabled because a completed region is serializable.
+Consequently **every task in a composed workflow must declare a version**, and
+its registry entry must supply the same version. Intermediate undeclared
+checkpoints recompute, per FLOW-FORMAT §7.6.
+
+Choices and work completions become explicit internal event names. Wait
+names receive a separate `event:` prefix, so an external caller cannot forge
+a work-completion event. Delays lower to statechart `after`; nested flows to
+compound states and `done` transitions. No third node scheduler is generated.
+
+Compilation exposes `lowered`, `revisions` (control and DAG content
+fingerprints), and a sorted `taskVersions` map qualified by control and node
+path. Trace and checkpoint records refer to these lowered identities. Exact
+canonical documents and maps, rather than a short content hash alone, decide
+resume compatibility. Runtime traces can vary in completion timing; values,
+control decisions and lowering are deterministic for equal inputs/events,
+explicit time and equal task results.
+
+## 4. Run, wait and resume
+
+```js
+const workflow = compileWorkflow(doc, {
+  tasks: { prepare: { version: '1', run: async ({input}, signal) => prepare(input, signal) } },
+  store,
+});
+const first = await workflow.run(input, { runId: 'review-7', now: 1000 });
+// first.status: 'waiting' or 'done'; first.snapshot is frozen JSON.
+const next = await workflow.run(input, {
+  runId: 'review-7', now: 2000,
+  expectedGeneration: first.snapshot.generation,
+  event: { type: 'approve', payload: { accept: true } },
+});
+```
+
+A run proceeds until a final state or an unhandled wait. The return value is
+`{status: 'waiting'|'done', result, snapshot}`; `result` is current data on
+completion and null while waiting. With no store, pass the previous snapshot
+as `snapshot` on the next call. Store and explicit snapshot are mutually
+exclusive. Resume requires the original input and matching exact identities;
+JF2013 is raised before loading any node result when they differ.
+
+One supplied event is delivered to the first wait reached by that call, then
+consumed even if no guard accepts it. Unknown events leave a wait unchanged.
+`expectedGeneration` rejects a stale event/resume with JF2014 before work.
+An accepted event is persisted in `context.event` before subsequent work, so
+an input query can consume `$.context.event.payload` after a durable wait.
+Callers needing durable event receipts maintain those in their host; duplicate
+external-event delivery is not an exactly-once input protocol.
+
+`now` is explicit statechart time. A resumed computation uses the supplied
+wake-up time for its next control transition. At a wait the bridge processes a due timer
+before the supplied external event, persisting each admission; this ordering
+is fixed. Fresh runs default to time zero. Work is not automatically timed
+out; cancellation belongs to the supplied `signal`. A host can wake a saved
+workflow using its snapshot's earliest deadline. No sleeping timer lives in
+the bridge.
+
+`onTrace` receives frozen records with `runId`, source `revision`, and lowered
+`revisions`. Node records add `type:'node'`, qualified `state`, activation
+visit, and the DAG's `id/status/ms`; transition records add ordered transition
+indices, entered/exited ids, active leaves and snapshot generation. A final
+`waiting`/`done` record names the settled control. Observer exceptions are
+isolated. Aborted DAG stragglers can still produce observation records; they
+cannot commit new work checkpoints after cancellation.
+
+## 5. Store, atomicity and crash windows
+
+A store implements async-or-sync methods:
+
+```js
+load(runId);                              // snapshot or null
+save(runId, snapshot, expectedGeneration); // true on atomic success, false if stale
+```
+
+`save` MUST atomically compare the existing generation, replace the complete
+snapshot and return true. Expected generation zero means the run is absent.
+The bridge claims a fresh generation before work, serializes concurrent DAG
+checkpoint writes, and awaits every durable write before the corresponding
+control change is visible. A failed write is JF2009; a failed comparison is
+JF2014. Same-instance concurrent calls for one run id refuse immediately;
+independent compiles/processes are fenced by the store's CAS. This is optimistic
+fencing, not an execution lease: overlapping workers can start external work
+before one loses its next CAS, so side effects still need the idempotency key.
+
+A snapshot carries format, run id, exact identities, generation, statechart
+control, data context, status and nullable pending DAG activation. Pending
+work carries state id, visit, captured input, per-node values, DAG provenance
+and, after completion, its result. On resume, declared node checkpoints seed
+the existing DAG memo; a recorded completed region skips the DAG altogether.
+Malformed control, visits, pending provenance and node declarations refuse.
+
+A crash after an effect succeeds but before its node checkpoint repeats that
+effect on resume. A crash after region completion but before control changes
+reuses the region result. Store implementations choose transaction durability
+and retention; the library promises no fsync, queue leasing or automatic
+compaction. All run data is currently stored in one bounded-by-the-host JSON
+snapshot; large histories should use a store with appropriate limits.
+
+Standalone DAGs can opt into the same exact provenance comparison with
+`compileDag(doc, {tasks,checkpoint,revision})`; see FLOW-FORMAT §7.9.
+
+## 6. Repository consumer and verification
+
+[The flow benchmark document](../../../benchmark/fixtures/flow-workflow.json)
+is the workflow executed by `npm run benchmark:flow`. Two correctness suites
+fan out in one DAG. A nested flow then runs the existing FSM and DAG benchmarks
+**sequentially**, retaining their measurement isolation and original assertions.
+A report task assembles their values. A choice optionally enters a persisted
+review wait; `retry` loops through at most three measurement rounds.
+
+```sh
+npm run benchmark:flow -- --quick
+npm run benchmark:flow -- --quick --review --checkpoint /tmp/flow-runs.json
+npm run benchmark:flow -- --checkpoint /tmp/flow-runs.json --accept
+```
+
+Omit `--quick` for normal benchmark iterations. Quick timings are smoke data,
+not replacement release measurements. Use a new `--run-id` for a fresh run;
+resuming a completed run intentionally returns its saved result. The file
+store uses an exclusive short lock plus atomic compare/rename; a lock left by
+a killed process must be inspected and removed by the host, never stolen based
+on elapsed time. Node/browser hosts may inject another CAS store.
+
+Tests cover this exact document's concurrency, ordered measurements and saved
+review/retry, plus general task/choice/loop/nesting/wait, failure/resume,
+checkpoint reuse, generation races, changed identities, cancellation and
+schema/compiler agreement. Streaming input, graphical editing, action-document
+awaiting and domain orchestration projections are separate contracts.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@jarenjs/flow",
   "private": false,
-  "version": "0.72.3",
+  "version": "0.75.0",
   "type": "module",
   "main": "./src/index.js",
   "types": "./dist/types/index.d.ts",
@@ -20,7 +20,7 @@
     "docs/",
     "schemas/"
   ],
-  "description": "Executable workflow documents for the Jaren suite: the jaren-fsm finite-state-machine format compiled to a pure step function, with query-document guards and effect descriptors as data",
+  "description": "Executable JSON workflows: pure FSMs and statecharts, concurrent DAGs, deterministic composition and durable checkpoint/resume",
   "author": "joham",
   "repository": {
     "type": "git",
@@ -49,7 +49,7 @@
     "prepack": "npm run build:types"
   },
   "dependencies": {
-    "@jarenjs/core": "^0.72.3",
-    "@jarenjs/json": "^0.72.3"
+    "@jarenjs/core": "^0.75.0",
+    "@jarenjs/json": "^0.75.0"
   }
 }

package/schemas/jaren-statechart-state.draft-07.schema.json

@@ -0,0 +1,72 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://jarenjs.dev/schemas/jaren-fsm/0.2/state/draft-07",
+  "title": "Jaren statechart snapshot",
+  "type": "object",
+  "properties": {
+    "active": {
+      "type": "array",
+      "items": {
+        "type": "string",
+        "minLength": 1
+      },
+      "minItems": 1,
+      "uniqueItems": true
+    },
+    "history": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "array",
+        "items": {
+          "type": "string",
+          "minLength": 1
+        },
+        "minItems": 1,
+        "uniqueItems": true
+      }
+    },
+    "timers": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "transition": {
+            "type": "integer",
+            "minimum": 0
+          },
+          "at": {
+            "type": "number"
+          },
+          "token": {
+            "type": "integer",
+            "minimum": 1,
+            "maximum": 9007199254740991
+          }
+        },
+        "required": [
+          "transition",
+          "at",
+          "token"
+        ],
+        "additionalProperties": false
+      },
+      "minItems": 0
+    },
+    "serial": {
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 9007199254740991
+    },
+    "time": {
+      "type": "number"
+    }
+  },
+  "required": [
+    "active",
+    "history",
+    "timers",
+    "serial",
+    "time"
+  ],
+  "additionalProperties": false
+}

package/schemas/jaren-statechart-state.schema.json

@@ -0,0 +1,72 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://jarenjs.dev/schemas/jaren-fsm/0.2/state",
+  "title": "Jaren statechart snapshot",
+  "type": "object",
+  "properties": {
+    "active": {
+      "type": "array",
+      "items": {
+        "type": "string",
+        "minLength": 1
+      },
+      "minItems": 1,
+      "uniqueItems": true
+    },
+    "history": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "array",
+        "items": {
+          "type": "string",
+          "minLength": 1
+        },
+        "minItems": 1,
+        "uniqueItems": true
+      }
+    },
+    "timers": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "transition": {
+            "type": "integer",
+            "minimum": 0
+          },
+          "at": {
+            "type": "number"
+          },
+          "token": {
+            "type": "integer",
+            "minimum": 1,
+            "maximum": 9007199254740991
+          }
+        },
+        "required": [
+          "transition",
+          "at",
+          "token"
+        ],
+        "additionalProperties": false
+      },
+      "minItems": 0
+    },
+    "serial": {
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 9007199254740991
+    },
+    "time": {
+      "type": "number"
+    }
+  },
+  "required": [
+    "active",
+    "history",
+    "timers",
+    "serial",
+    "time"
+  ],
+  "additionalProperties": false
+}