Stateful systems · deterministic fixture lab

Break the journey before production does.

Execute every published Mappls application lifecycle from creation to a reviewed operating outcome. Prove idempotency, optimistic concurrency, invalid-state rejection, immutable events, and unknown-outcome recovery without credentials, provider calls, or durable writes.

Run a journey Design the operating model

18complete lifecycles

Every published stateful or hybrid journey.

90deterministic paths

Five hostile and success scenarios per journey.

140guarded transitions

Commands, versions, identities, actors, and facts.

6client languages

One synchronized fixture contract.

Choose the evidence

Run one complete fixture

JourneyScenario

Only two catalog identities are accepted. No credential, resource ID, location, payload, URL, or provider input exists.

Unknown outcome recovery

iOS direction planning and navigation handoff

Reconcile after a lost response, then replay the original command identity safely.

fixture only

The report proves deterministic application-side state-machine behavior only. It is not Mappls entitlement, provider resource, webhook, performance, regional, or production evidence.

Aggregate: route planning session
Start: draft
Result: draft
Version: 1

Read catalog JSON Open full blueprint

Execution evidence

Every attempted command remains visible.

Accepted commands advance exactly once. Replays, conflicts, invalid transitions, and reconciliation are evidence—not hidden control flow.

acceptedcreate_plan

transition_committed

new aggregatedraftv0 → v1

The fixture commits the transition, but simulates the caller losing the response.

Immutable application eventroute_plan.createdevt_fixture_ios-direction-planning-handoff_01

reconciledreconcile

reconciled_after_unknown_outcome

draftdraftv1 → v1

The committed aggregate version and original command identity are found after the caller observed a timeout.

replayedcreate_plan

idempotent_replay

draftdraftv1 → v1

The original committed result is returned without another version or event.

Immutable application eventroute_plan.createdevt_fixture_ios-direction-planning-handoff_01

Executable assertions

The report explains why it passed.

Only catalog identities acceptedbounded-input

pass

No Mappls provider request madeno-provider-call

pass

Accepted transitions increment exactly oncemonotonic-version

pass

Accepted transitions emit unique immutable eventsunique-events

pass

Rejected commands emit no eventrejection-safe

pass

Replays do not increment versionreplay-safe

pass

Scenario reaches its declared evidence outcometarget

pass

Shared state contract

What the simulator will never blur.

01
This is an application-owned deterministic fixture. It makes no Mappls provider request and claims no provider webhook payload.
02
Idempotency is checked before optimistic concurrency so an exact retry can return the first committed result.
03
A reused idempotency key with different intent would be a conflict; applications must persist a request fingerprint with the result.
04
Rejected commands do not change the aggregate version and do not emit an event.
05
Accepted commands commit the aggregate snapshot, immutable event, audit evidence, and transactional outbox intent atomically.
06
A timeout is an unknown outcome. Reconcile by aggregate and command identity before replaying the same key.

Six synchronized clients

Automate this exact evidence path.

These examples call the credential-free simulator—not a Mappls provider endpoint. Production commands must use your trusted application boundary and actual reviewed provider contract.

cURLcurl

curl --request POST 'https://developer.mappls.com/api/journey-simulator' \
+  --header 'content-type: application/json' \
+  --data '{"journey":"ios-direction-planning-handoff","scenario":"unknown-outcome"}'

JavaScriptjavascript

const response = await fetch("https://developer.mappls.com/api/journey-simulator", {
  method: "POST",
  headers: { "content-type": "application/json" },
  body: JSON.stringify({"journey":"ios-direction-planning-handoff","scenario":"unknown-outcome"}),
});
if (!response.ok) throw new Error(`Simulation failed: ${response.status}`);
const report = await response.json();
console.log(report.finalSnapshot, report.checks);

Pythonpython

import requests

response = requests.post(
    "https://developer.mappls.com/api/journey-simulator",
    json={"journey":"ios-direction-planning-handoff","scenario":"unknown-outcome"},
    timeout=10,
)
response.raise_for_status()
report = response.json()
print(report["finalSnapshot"], report["checks"])

Javajava

var request = HttpRequest.newBuilder(URI.create("https://developer.mappls.com/api/journey-simulator"))
    .header("content-type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString("{\"journey\":\"ios-direction-planning-handoff\",\"scenario\":\"unknown-outcome\"}"))
    .build();
var response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
if (response.statusCode() != 200) throw new IllegalStateException("Simulation failed");

Gogo

payload := strings.NewReader(`{"journey":"ios-direction-planning-handoff","scenario":"unknown-outcome"}`)
request, err := http.NewRequest(http.MethodPost, "https://developer.mappls.com/api/journey-simulator", payload)
if err != nil { return err }
request.Header.Set("content-type", "application/json")
response, err := (&http.Client{Timeout: 10 * time.Second}).Do(request)
if err != nil { return err }
defer response.Body.Close()

C#csharp

using var client = new HttpClient { Timeout = TimeSpan.FromSeconds(10) };
using var content = new StringContent(@"{""journey"":""ios-direction-planning-handoff"",""scenario"":""unknown-outcome""}", Encoding.UTF8, "application/json");
using var response = await client.PostAsync("https://developer.mappls.com/api/journey-simulator", content);
response.EnsureSuccessStatusCode();
var report = await response.Content.ReadAsStringAsync();