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.

Application target: Local app / Original environment
+ Reach state: Open final state / Replay journey
+ Browser session: Development Profile / Clean Session
+ DevTools: Open after state is ready
+ optional protected-value consent
→ Open State

The card’s Captured from information supplies the optional Original environment target. StatePort never accepts an arbitrary remote URL and never switches targets silently. Open final state restores Saved state; Replay journey runs the Recorded Journey. For an eligible saved-page attempt, the launch button instead says Try Saved State or Try Recorded Journey.

Before you reproduce

1. For Local app, 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. Choose Local app or, when the Card offers it, Original environment.
5. Choose how StatePort 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.

StatePort fails closed on these conditions instead of guessing another target or silently contacting the captured source. After a run with missing responses, open Run details → Show network miss reasons to inspect safe method, path, occurrence and reason. Request bodies, credentials, headers and query values are not shown.

Get Developer access without leaving the Card

When the launcher reports Developer access required, it keeps the current State Card and reproduction choices visible and offers:

• Start 14-day Developer trial;
• View Developer plans;
• Recover existing access.

Starting the trial opens an inline email form. Entering an email or requesting a verification code does not start trial time. The trial starts only after the code is verified; no payment card, password, or StatePort account is required.

Retryable service errors keep the email or code in the focused form. You can retry, request a new code, change the email, cancel back to the launcher, or open Developer plans. If the access check itself is unavailable, use Retry access check; the State Card settings remain unchanged.

After successful verification, Desktop shows Developer trial started and the remaining days, checks access again, preserves the selected path, target, browser session, DevTools choice, and per-run protected-value consent, then focuses the enabled launch action. It never starts reproduction automatically.

Choose an application target

Official reproduction support starts with Capture Session 1.23.0. Recapture older Cards with the current version before relying on their reproduction. Older readers may still work, but that behavior is best-effort.

Local app opens the saved state against the loopback app you enter. If that app proxies backend requests through the same localhost origin, its current pages and assets still load locally. Exact retained backend responses come from the Card; unmatched or non-replayable requests are blocked. A different local database needs its own local sign-in Persona.

Original environment uses the Card’s exact source origin under the disclosed network policy:

• A Card with eligible retained page material serves the saved page and captured responses locally, without contacting production.
• A Chrome Capture Card loads the current application code and permitted public assets from its exact source origin. The extension does not archive application code, so this path requires the site to be reachable and is not offline reproduction of the captured code.
• A compatible legacy Card may also load the current application shell from its exact captured origin.

Original environment is not an editable URL field or a general remote browser-control session. Open Network → Details to inspect which policy applies to this Card. Captured API data takes precedence in every path; unmatched fetch/XHR/data requests and mutations are blocked. Missing required material stays an explicit limitation rather than granting broader network access.

If you saved a Chrome Capture with Keep current browser sign-in on this device, StatePort keeps updated values of the selected session cookies locally after a successful opening and when you stop. It does not extend their saved lifetime. If the site has already rejected the saved session, signing in again in ordinary Chrome alone does not update the Card’s local sign-in: capture fresh sign-in material with Keep enabled. Ordinary sharing does not carry it.

A single-page application may load one HTML page and change its address before the first checkpoint. When the Card retains that initial navigation and its HTML, Original environment starts from the saved page and checks that the application reaches the checkpoint route. It does not need the original server or its VPN connection. Missing or ambiguous startup material remains a blocker.

Choose how to reach the state

Saved state

Choose Open final state when you want to start directly from the selected Saved state preserved by the Card.

If the Card says an external surface requires Journey, Saved state still opens the selected checkpoint but does not claim to recreate that transient popup or widget. Choose Replay journey to replay its creating action and verify the typed surface readiness outcome.

StatePort validates the exact card/revision, current loopback target, browser-session readiness, authentication boundary, and replay policy before launching the browser. Private replay data that cannot be used with the selected target or browser session is reported before other prerequisites. Otherwise, if several issues coexist, Open shows the current target, access, authentication, or browser-session prerequisite before a separate Card-compatibility block. The compatibility reasons remain available, and replay cannot start until the required checks pass.

During interactive Saved state and Recorded Journey playback, the managed browser stays visible and shows a floating 0–100% progress indicator. It tracks restoration stages or completed Journey actions; the final run result, rather than the percentage alone, determines whether reproduction was confirmed. If you open a Saved state, an opaque cover hides the application while it is being restored, then disappears when the restored state is ready. If replay fails, the indicator shows an error. After playback reaches a terminal state, its close button closes the managed browser. For a terminal Journey, closing the browser also finalizes the trusted result shown in Active session, just like Finish and show result.

Before launch, StatePort may show a compatibility assessment derived from trusted Card and runtime evidence:

• Supported means no known blocker was found; it is not a promise that an arbitrary application behavior is supported.
• Limited keeps an otherwise usable path available and names the known reproducibility limitation.
• Blocked prevents launch when a required captured capability, replay dependency, authentication boundary, or managed-browser prerequisite is not available.

The same safe assessment is shown in Capture Review before Save and in the State Card launcher before Open. A failed or incomplete capture finalization never becomes a ready review. Compatibility details contain typed reasons and recovery actions, not request bodies, credentials, or protected values.

Recorded Journey

Choose Replay journey when the reproduction should advance through the approved Recorded Journey captured for the Card.

A Journey may be:

• Full — all recorded supported steps can run automatically;
• Zero-step — a Card captured as one saved screen opens that checkpoint and completes without replaying actions;
• 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.

StatePort 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.

For a Chrome Capture link whose target was ambiguous, Journey can use an immediately recorded page transition when its exact destination checkpoint was saved. This replays the saved route, including its query, rather than the link’s client-side handler. Such transitions may reload the page. Other unsupported clicks still limit Journey. This correction also applies to existing Cards; they do not need to be recorded again.

Choose the browser session

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

For Local app, either browser session can be used with Saved state or Recorded Journey. Original environment uses an isolated Clean Session; Development Profile is unavailable for that target.

Reproduction uses StatePort’s managed browser, including for a Card recorded from an ordinary Chrome tab. It does not copy or reset your ordinary Chrome profile.

To prepare site sign-ins or browser preferences before a capture, go to Settings → Development Profile → Open Development Profile. This opens the managed browser without recording a Capture Session. Close that browser before starting Capture or Replay with the same profile.

In Settings, expand About local data and verification for details on what stays on your device. Reset Development Profile clears this local browser setup after confirmation; it does not delete your State Cards or saved work.

You can open this documentation anytime using Documentation next to Settings in the app sidebar.

DevTools

Under DevTools, Open after state is ready 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, StatePort follows the safe manual/barrier behavior available to that Card rather than using the value implicitly.

Card-only transfer omits the retained value. The recipient may need to enter missing input at a manual barrier, or supply separately accepted Private replay data for Original environment. A Card saved after confirmed discard retains its sanitized manual step. Desktop can also offer explicit protected transfer as described below.

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.

When current code changes a request

If current code sends a request that differs from the one captured in the selected revision, StatePort first stops and shows a safe structured difference. It distinguishes one bounded parameter change from a new request, multiple plausible captured requests, or an extra occurrence. It never chooses a predecessor or contacts the captured backend automatically.

For one eligible same-method/path query, JSON, or supported GraphQL-variable change, you can choose Use captured response for this request. This creates an exact experiment for that signature and occurrence. A successful result says Frontend checked with a captured response: it checks the current frontend against the previous captured response, but does not verify the new backend request. Save it only as a child revision; the source Card remains unchanged.

If an already configured and authorized live route handles the request, the result says Checked against the configured live target. That is evidence about the target now, not a reconstruction of capture-time backend state. Method, path, operation, ambiguous, unsupported, and non-replayable changes do not offer a captured-response mapping.

Reproduce

Choose Open State after the launcher is ready, or Try Saved State / Try Recorded Journey when that saved-page attempt is offered.

The launcher first returns one of two truthful states. Blocked means a typed preflight reason remains on the State Card and no run was accepted. Accepted and starting means StatePort has persisted the exact attempt and opened the Active reproduction workspace; it does not mean the saved state has been reached.

StatePort then:

1. validates the selected Card/revision and reproduction method;
2. validates the selected application 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;
7. persists one terminal result before reporting success.

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. The result persists for the exact State Card revision and is still available after restarting Desktop. Related or later revisions do not inherit it.

The terminal result is confirmed, partial, not confirmed, failed, unsupported, or cancelled. Every result except confirmed includes one primary reason and a recovery action when one is currently available. Browser opening, navigation, or process completion alone never becomes confirmation.

For confirmed, partial, and not-confirmed results, This is not the saved state lets you record that the visible result is wrong. This separate verdict does not modify the State Card or replace the original machine evidence.

Older readable runs that predate trusted qualification say Result not classified by this version. They are not upgraded from completed to confirmed.

Below the Open controls, Bug context shows saved Notes, Observed behavior and Expected behavior. Use Add bug context or Edit bug context to update them, then Save context. Cancel leaves the saved context unchanged.

Expand Latest run for its result, history and available recovery actions. The Captured summary at the end shows the final page, checkpoint count, replayable responses, console issue count and retained local sensitive values.

StatePort 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, StatePort can expose a bounded redacted projection through the supported response editor.

An edit must apply exactly to the safe fields shown. Some changes, including setting a field to null or replacing an array or object that contains hidden data, cannot be applied safely. The editor explains the refusal and keeps your draft. Reset the changes or choose another response; the saved State Card stays unchanged.

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.

Desktop can separately include explicitly selected protected values or a Protected Persona. Review the selection and any production/customer warning before creating the link. The recipient can import the Card only or explicitly accept the offered material into protected local storage. Card-only transfer omits protected material and retains the disclosed replay limitations or manual input steps.

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 StatePort:

• target unavailable → start or correct the loopback application; for a Chrome Capture or legacy Original environment path, check that the exact source site is reachable;
• 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.