Reproduce a saved State Card

Reproduce a saved State Card

A State Card is the starting point for developer work against your current code.

The current Desktop uses one reproduction launcher rather than separate Open, Replay, and Verify wizards.

Current local app target
+ Reach state: Saved state / Recorded Journey
+ Browser session: Development Profile / Clean Session
+ Open DevTools
+ optional protected-value consent
→ Reproduce

The card’s Captured from information is provenance only. ScenarioDeck does not silently use the captured remote origin as the reproduction target.

Before you reproduce

1. Run the application you are changing on an approved loopback address such as http://localhost:3000.
2. Open the State Card from the Library.
3. Review its objective, Saved state/Journey availability, current sharing/safety status, and any relevant evidence.
4. Enter or confirm the Current local app target.
5. Choose how ScenarioDeck should reach the state and which browser session to use.
6. Resolve any exact blocker shown next to the launcher.

Typical blockers include:

• local target unavailable;
• authentication or re-authentication required;
• incompatible or partial captured state;
• managed browser/profile unavailable;
• protected local value not authorized for this run;
• Developer access required.

ScenarioDeck fails closed on these conditions instead of guessing another target or silently contacting the captured source.

Choose how to reach the state

Saved state

Use Saved state when you want to start directly from the selected checkpoint/state preserved by the Card.

ScenarioDeck validates the exact card/revision, current loopback target, browser-session readiness, authentication boundary, and replay policy before launching the browser.

Recorded Journey

Use Recorded Journey when the reproduction should advance through the approved semantic path captured for the Card.

A Journey may be:

• Full — all recorded supported steps can run automatically;
• Partial — automatic segments are separated by one or more explicit manual barriers;
• unavailable — the Card can still be useful through Saved state when compatible.

A partial Journey pauses at the manual barrier, waits for the user to complete the required step, then resumes the later automatic segment when you choose Resume.

ScenarioDeck does not guess through an ambiguous semantic target, use CSS/XPath/coordinate fallback, expand network access, or force an unsafe side effect merely to keep a Journey running.

Choose the browser session

• Development Profile — ScenarioDeck’s persistent local browser profile for everyday work.
• Clean Session — a fresh isolated browser context that does not depend on Development Profile state.

The browser-session choice is independent from whether you use Saved state or Recorded Journey.

ScenarioDeck does not attach to or modify your normal Chrome profile.

DevTools

Open DevTools is enabled by default for interactive Desktop reproduction. Turn it off when you do not need browser DevTools for that run.

DevTools is part of the local interactive workflow and does not require an externally reachable debugging port.

Protected local values

If the Card retained a supported protected value on this device, the reproduction launcher shows an explicit per-run authorization choice.

The value is never exposed in the normal renderer. If you do not authorize it, ScenarioDeck follows the safe manual/barrier behavior available to that Card rather than using the value implicitly.

Ordinary sharing remains unavailable while a Card requires a retained machine-local protected value. A Card saved after confirmed discard uses a manual barrier instead and can use ordinary credential-free sharing when no other blocker remains.

Network behavior

Captured supporting behavior remains controlled by the Card’s replay policy. An unmatched in-scope request stops with a typed miss rather than becoming a silent request to the source environment.

A supported dependency may be routed explicitly to an approved loopback Local target while the surrounding captured world remains replayed. Captured/source credentials are not automatically forwarded to Local.

Reproduce

Choose Reproduce after the launcher is ready.

ScenarioDeck then:

1. validates the selected Card/revision and reproduction method;
2. validates the current local target and browser-session readiness;
3. applies fail-closed routing before navigation;
4. opens the managed browser;
5. restores Saved state or executes the Recorded Journey;
6. records bounded safe evidence for the run.

Returning from a run keeps the safe launcher choices needed for another reproduction. Protected-value consent resets and must be explicit again for a later run.

Latest run and evidence

After a run, the State Card workspace shows a compact Latest run result and progressively disclosed evidence such as:

• Journey/checkpoint progress;
• browser console and page errors;
• network evidence;
• supported application-state evidence;
• safety and portability status;
• revisions, runs, and comparisons;
• technical details when needed.

ScenarioDeck reports observed evidence. It does not infer Fixed, Root cause, or Expected behavior satisfied merely because an error disappeared or one run completed.

Run a controlled experiment

For an eligible replayed JSON response, ScenarioDeck can expose a bounded redacted projection through the supported response editor.

You may:

1. inspect the safe editable projection;
2. change it through Form, Tree, or JSON mode;
3. review the safe old/new diff;
4. apply the validated overlay;
5. save the result as an immutable revision;
6. reproduce the revision again against current code and compare compatible run evidence.

The source Capture Session/State Capsule remains unchanged. Unsupported, stale, oversized, binary, auth-bearing, or unverifiable material is not exposed as editable data.

Share a State Card

Sharing is a secondary action in the same State Card workspace.

The sender flow is:

Share
→ review Included / Not included
→ choose expiry
→ Create share link
→ Link ready
→ Copy link
→ active share
→ Revoke when needed

Creating a share and copying its link are distinct states. Closing the Share panel does not revoke an active share.

An ordinary share carries the credential-free portable reproduction. It does not include machine-local protected values, Development Profile contents, local Auth Binding values, or local sign-in state.

If the Card retains a protected local value required by the workflow, ScenarioDeck denies ordinary sharing before upload and explains the reason. A sanitized Card saved after confirmed discard can share normally and keeps the corresponding manual barrier for the recipient.

The recipient opens the secure share landing, imports the State Card locally without an account, and then chooses their own current-code target and local authentication as needed.

Sending, receiving, importing, and inspecting one supported State Card are Free Capture operations. Developer access is required only when the recipient chooses to execute the saved reproduction against current code.

When reproduction stops

Use the typed reason and recovery shown by ScenarioDeck:

• target unavailable → start or correct the loopback application;
• auth required → bind or re-authenticate the approved local Persona;
• protected value not authorized → authorize it for this run or continue through the Card’s manual path when available;
• request mismatch → inspect the safe replay/network evidence;
• Journey target missing or ambiguous → correct the current app state/code or use another supported Card path;
• unsupported or partial capture → recapture within supported scope;
• Developer access required → explicitly start the trial or restore paid Developer access.

A normal recovery should not require interpreting a raw stack trace or exposing captured secrets.