Supported Public Beta scope

StatePort is designed for state-heavy web-application workflows where the useful reproduction can be represented through supported browser state, semantic actions, checkpoints, and captured HTTP behavior.

The current public release is a Public Beta. Platform availability is separate from feature scope: use stateport.dev/download to see which operating systems and architectures are currently published.

Good fit

Role, permission, feature-flag, account, form, validation, error, and empty-state workflows.
Manual Capture in StatePort’s managed browser.
Capture of an explicitly selected ordinary Chrome tab through the packaged extension, with its source-specific limitations.
The current direct automated-test Capture path for a selected supported CodeceptJS browser test.
Reopening a saved state against an explicit loopback/current-code target.
Reopening a Card in Original environment, using its eligible saved page or its disclosed current-source path with matching captured API data replayed and unmatched data/mutations blocked.
Full or partial Recorded Journeys with exact semantic steps and manual barriers where needed.
Captured supporting HTTP responses kept controlled while current code changes.
Deterministic safe diagnosis of changed query/JSON/supported GraphQL-variable requests, with an explicit exact captured-response experiment when one eligible predecessor exists.
A selected supported dependency routed explicitly to loopback Local while the surrounding captured world remains replayed.
Browser console/page-error evidence captured under the selected evidence policy.
One-card encrypted sharing, offline State Card file export/import, and ordinary credential-free handoff.
Supported local authentication through StatePort-owned browser/profile and Auth Persona/Binding boundaries.
Common client-rendered authenticated apps whose selected localStorage, sessionStorage, cookie/HttpOnly-cookie or exact target-local header session can be validated at a configured post-login checkpoint.

Known Public Beta limitations

Current Capture retains safely admitted request/response material and observed network outcomes. Offline replay reproduces captured request failures and leaves requests captured as pending at Stop unresolved. Browser beacon/ping traffic uses an unused captured occurrence for the same method and URL, without returning an HTTP response. Its native queue acceptance is preserved and does not prove server success. Fetch/XHR, including keepalive Fetch, still requires an exact matching request body. An exact GET/HEAD read can reuse its saved response when all recorded responses for that request are identical. This does not allow a different URL/body, repeated mutations, or extra failure/pending/ping outcomes; unknown requests and exhausted finite sequences fail closed. Protected-input, opaque and multipart request bodies are omitted. Current managed Capture can retain bounded native WebSocket transcripts for anonymous same-origin text exchanges that complete a successful native handshake. Saved State and Journey can replay those exact ordered transcripts locally before navigation, with no remote socket fallback. Binary, cross-origin, unsafe, over-limit, unavailable, changed or additional socket traffic remains unsupported and is reported explicitly.

External provider surfaces

StatePort does not promise deterministic capture and Frozen recreation of arbitrary third-party surfaces. Current bounded support includes safely captured HTTP(S) documents/scripts/styles/fonts/images/fetch/XHR, redirects and CORS/preflight, iframe/popup, injected DOM/open Shadow DOM, finite SSE, bounded workers, non-DRM progressive media, and bounded manifest/segment media cases that pass the Card’s Frozen readiness proof. Examples that still require explicit review include:

cross-origin payment or booking forms;
support/chat widgets;
maps and geospatial widgets;
external media players;
OAuth/consent/auth widgets;
cross-origin iframes and popups with provider state outside captured HTTP material;
WebSocket-driven surfaces and unbounded server-sent-event streams;
worker/service-worker-backed UI;
large or unbounded media, upload, or download flows.

When trusted capture or runtime evidence identifies a limitation, Capture Review and the State Card launcher show the specific reason. Non-blocking notes stay compact, with explanation and suggested next steps under Details; actual blockers remain prominent. A previous failed attempt and an unconfirmed capture check are different: the latter does not prove that replay fails. A normal supported HTTP/JSON Card has no warning. Incidental unsupported traffic does not become a blocker unless the retained evidence says the application state requires it. A required unsupported protocol, missing replay dependency, incomplete finalization, authentication blocker, or unavailable managed browser cannot be presented as ready. StatePort does not silently fall back to the live provider or captured source system.

Captured source boundary

Safe page resources remain saved even when offline completeness is unknown. The launcher’s network details also say when no successful scenario verification is saved for the Card; this is not a warning that Open or Journey failed. Saving alone does not guarantee verified reproduction. For an eligible anonymous Clean Session capture, Save may check the selected state and Journey offline. Separately, Desktop may check the newly saved revision against the selected Local app when Developer access, target, authentication/consent and foreground browser prerequisites are already satisfied. Otherwise it records why reopening was not checked. Neither check starts Developer access or silently chooses a target. See Save the State Card. If the exact retained entry page is available, use Try Saved State or Try Recorded Journey in the original environment with a Clean Session. The attempt uses saved material locally, without contacting production, and blocks unmatched requests. An unmatched request does not by itself stop an ordinary saved-material attempt: actions can continue, while the missing response remains in the run details. A failed action or wrong state still fails, and continuing does not turn an incomplete run into a verified one. If the retained entry page is missing, inspect the saved material or use an explicit Local app target with your current app. A Chrome Capture or compatible legacy Card may instead offer the disclosed current-source path described below. Unsupported required capabilities and authentication constraints still block execution. A successful Open does not by itself mark the scenario verified.

Original environment is not a promise to reproduce an arbitrary remote environment or live backend. A Card with eligible retained page material serves its saved page and responses locally, without contacting production. Chrome Capture does not archive application code: its Original environment path contacts the exact source site for current application code and permitted public assets. A compatible legacy Card may also load its current source shell. These paths require the site to be reachable and do not provide a zero-egress guarantee. Network → Details explains the Card’s policy. Captured API data takes precedence in every path; unmatched data requests and mutations are blocked. Service-worker-backed behavior, WebSocket traffic outside the bounded transcript contract and unsupported redirects remain outside the supported boundary and fail closed.

New eligible anonymous Captured-source Cards start the saved page’s Date at capture time and let it advance normally. This avoids aging the page’s initial data while the Card is stored. It does not recreate every browser clock: timers, worker clocks and implicit-current-time Intl remain native. Time-sensitive behavior can still prevent reproduction. Current local app and authenticated execution keep their normal time behavior; older Cards need a fresh capture to gain this capability.

Cloudflare and anti-bot verification

Cloudflare, Turnstile, CAPTCHA, and similar anti-bot protected sites may fail to complete their verification flow inside the managed Capture browser. StatePort does not bypass or solve those controls. If the verification cannot complete, treat that site as unsupported for the current Public Beta workflow.

Backend and environment state

StatePort does not capture or recreate:

database snapshots;
server-memory snapshots;
queue or distributed-process state;
arbitrary backend virtualization;
a full production environment clone.

A response captured for request A is not the counterfactual historical response for a new request B. StatePort can explicitly reuse A’s response to test frontend behavior, or use an already authorized configured live target and report what it returns now. Neither path establishes historical backend equivalence, backend correctness, or that a bug is fixed. Current-backend baseline and drift analysis are not part of this Public Beta workflow.

Browser and protocol boundaries

Confirm the workflow before relying on StatePort for SSR-specific behavior, GraphQL subscriptions, WebSocket traffic outside the bounded transcript contract, unbounded SSE, OAuth/external redirects, shared/service workers, file upload/download, large or unbounded segmented media flows, DRM/WebRTC, or behavior that depends on arbitrary browser extensions.

Chrome Capture records only the tab explicitly selected by the user. It does not copy the Chrome profile or give MCP/agents control of that tab. Reproduction uses StatePort’s managed browser; its two browser-session modes do not select your ordinary Chrome profile.

Sensitive values

Raw sensitive values are always excluded from ordinary State Cards and Capsules. Desktop manual Capture holds supported candidates encrypted on this device for Review by default; choose Skip sensitive values during Capture to omit them.

For a supported protected candidate, the creator may explicitly keep the value in OS-protected machine-local storage. A retained protected value:

stays available only on that device;
requires explicit authorization for each reproduction run that uses it;
is not included in an ordinary State Card share;
is omitted from Card-only transfer, which may require manual input or separately accepted protected replay material on the recipient’s device.

If the creator confirms Discard, StatePort removes the protected local value, derives a sanitized saved Session, and turns that Journey point into a manual barrier. Ordinary credential-free sharing can then proceed when no other blocker remains.

An eligible authenticated session may be shared only as a visibly selected, separately encrypted Protected Persona. Share preselects only the Card-bound or sole eligible validated Persona and never guesses among ambiguous choices. The sender may choose Card-only instead; protected-link creation and recipient acceptance remain explicit. Exact scope, expiry, one-time use and production/customer policy are enforced before recipient-local install. Protected Persona transfer excludes browser profiles, passwords, MFA/passkey factors and arbitrary cookie domain rewrites. A separately selected supported protected input can travel as a Protected Sensitive Attachment, with explicit sender selection and recipient acceptance; it never enters the ordinary Card.

Offline State Card files

Export State Card… and Import State Card… move one State Card without an account or Share relay. A Card-only file excludes protected values, local sign-in, Auth Bindings, Development Profile data and local consent/preferences.

Desktop Export also offers explicitly selected protected values / Private replay data or a Protected Persona, using the same separate envelopes as Share. Import shows the same preview and acceptance choices as a link; protected material is installed into recipient-local protected storage only after explicit acceptance. Card-only import remains available without accepting that material.

Anyone with the exported file can access the selected included data. The file is not password-protected, and a delivered file cannot be revoked remotely. Accepted protected material retains its scope, expiry and use policy. See Transferring by file.

Automated tests

The current direct test-runner integration is CodeceptJS Run & Capture for one selected browser test. StatePort is not a generic test runner and does not claim direct support for arbitrary Playwright Test, Cypress, Selenium, CI-provider, or other runner workflows.

Fail-closed behavior

Unsupported behavior is reported explicitly. StatePort does not make a failed reproduction look successful by broadening network access, guessing ambiguous semantic targets, silently contacting the captured remote system, or claiming automatic root cause or bug fixing.

state list, state inspect, and state history in the CLI, plus list_states, inspect_state, and get_state_history in MCP, expose the same versioned aggregate compatibility and exact-Card terminal history used by Desktop. These machine-readable responses carry only typed status, recovery, and aggregate evidence; they do not expose raw network evidence or authentication material.