Skip to content

Browser record sources

Use Direct IQ to decode the receiver's signal in your browser. If the Pi already runs a continuous HRIT job, you can read its retained records and reconstruct products without a second IQ stream. A paired Server can supply archived records or products it has already built. Server performance and catch-up qualification are tracked in evidence and limits.

Choose a source

Open SATCOM → GOES → Configure source in the upper workspace header. It groups the selected source, server/stream identity and consumption controls; live appliance reception and Dock / close remain on the right. The compact HRIT/LRIT header below reports processing, activity, transfers and issues. Choose:

  • Direct IQ: choose an existing Primary/Secondary IQ lane and retain its receiver/decoder ownership. The draft lane changes only when Apply is selected; it does not acquire or retune hardware or start decoding.
  • Appliance records: choose a compatible, already configured job from the connected appliance. The list includes its protocol, running/stopped state and retained record count.
  • Server archive: choose a known or discovered Server, then one of its accessible archived streams. Retained streams remain available when their originating appliance is offline. Catalog pages are bounded; use Next streams or First page to navigate larger catalogs.
  • Server products: choose one trusted compatible Server and original stream. Download the Server's published revisions into the browser archive and open them in the usual viewers. Partial images retain their coverage and can be replaced by later revisions. Reconstruction and color processing run on the Server.

Apply source deliberately connects or switches. Cancel, Escape or closing the panel preserves the current source; closing the panel never stops reading. Raw identities, endpoints and exact positions are under Advanced / Diagnostics. No UUID or reader-token entry is needed. Reading/discovery does not acquire or retune a receiver, start a decoder, or stop an existing job. Direct IQ remains usable with zero Servers. GOES-R HRIT/EMWIN is the installed record processor; incompatible streams are labeled and cannot be selected for it.

Server-product downloads and retention

Overview/all-products pages use the archive owner's maintained total for an unfiltered all-time query. Date/filtered counts use short cancellable read turns so an exact count cannot monopolize publication/retention transactions. Cleanup refreshes wait behind an active query; changing the selection still cancels it. Cleanup activity reports products retired and files reclaimed, not pending work. Weather history warming reads bounded 32-entry metadata pages in bulk. Asset reclamation checks for a remaining reference without counting every reference; shared assets remain protected until no product refers to them. Retention merges bounded family/receipt/product index heads in oldest-first order, continuing past an exact product ID when many products share a receipt time. Periodic checks for other writers restart after a cleanup pass settles, rather than repeatedly revisiting the retired prefix while that pass is still making progress.

Enable processing deliberately on the Server first; pairing/upgrades alone do not activate it. The Server handles recent/live input independently of bounded newest-first historical work. Its recent-history target is not a guarantee that every product in that window has all constituents. Observation time, input receipt time and publication time are different; a newly published historical image still belongs to its old observation time.

Under All products → Retention and storage, thumbnails/details/text arrive first. Native imagery defaults to When selected, with Recent products available for an explicit hour window. Originals default to On demand, with Retain automatically optional. All share the bounded download-staging allowance. A thumbnail does not make the full image offline-ready; opening/exporting an absent native/original asset schedules a verified resumable transfer. Keep the appliance-served browser and Server versions compatible and reload after upgrade. Unsupported identifiable products are deferred without blocking supported ones.

When an older snapshot is unfinished, bounded recent-head checks also queue current products. Those additions commit to the same pending-work journal without advancing the historical snapshot or change cursor. Newest items take priority; the older discovery walk continues, and reload reuses completed-fetch receipts.

Discovery, durable pending transfers and local publication advance separately. Quota failure, cancellation/reload and outages retain pending work and prior products. Upstream production health is shown separately from transfer health; older Servers may report it as unknown. A successful catalog poll is not proof of new production. Source transitions never silently start expensive local reconstruction: configured fallback needs a valid local checkpoint/replay boundary.

Local retention remains independent of Server product and raw-record retention. Changing it can schedule bounded local cleanup; it does not delete Server copies. Superseded partial imports coalesce to the preferred revision, retire replaced assets after metadata commit and preserve original evidence. Server expiry never commands deletion of an independently retained browser observation. Existing current/complete products remain usable during failed replacement and offline.

Two viewer follow-ups remain open: #5 radar preparation with the main document hidden and #6 Full Disk cold-loading. Showing the main document unblocked the recorded radar case; this is a diagnostic workaround. A Full Disk cold open may include remote native retrieval despite local-read wording; its serial transfer/decode costs and cache admission need separate measurement. Acceptance does not claim those follow-ups are fixed.

Startup and activity

The GOES header names the actual operation, including restoring a checkpoint, replaying retained inputs, connecting or waiting for first records. Local replay is distinct from source transfer. Primary and historical rates remain separate: Not measured or a dash means no current measurement is available; 0 B/s is a measured quiet interval. Rates use canonical transport-record bytes, excluding HTTP/TLS overhead. Operation details contain explanatory prose and elapsed-time context; record progress details contain exact retry/durability times.

Records received this run is the primary consumer's transport counter. It includes configuration/dependency records and duplicate deliveries, increments before durable commitment, and excludes local checkpoint replay and the separate historical reader. It resets when the consumer is replaced, not on every network reconnect. After that consumer exits, retained counts are labeled last primary run. The historical counter combines completed range attempts with the current attempt; a range retry resets its own portion, and replacing the coordinator resets the whole counter. Neither count is a stored-product or Server-archive total. Header and Overview use the same labels and adjacent counter explanations.

Open Startup & activity beside the current operation for the latest 80 lifecycle entries. Current running operations appear first, then waiting/blocked operations, then completed/failed/stopped history newest first. Current entries are deduplicated by lifecycle channel. Rows distinguish local preparation, source connection, record transfer and reconstruction, with local timestamps, elapsed durations and available counts. Shared product storage and index work may run alongside the forward and historical readers; the log does not imply these operations run one after another. A long-running operation shows what it is waiting for and whether reports are still arriving, without declaring a failure from elapsed time alone. Reported failures retain the existing actions in Configure source and View errors. The issue trigger keeps its severity visible; its disclosure contains the full message, outcome and historical-reader failures. Activity, operation and issue panels open beside/below their own trigger, flip or shift to fit that window's viewport, and close with Close, Escape or an outside interaction. Opening another coordinated disclosure closes the prior one. Keyboard opening enters the panel and closing returns focus to its trigger. Panels do not push imagery downward or depend on the old source-bar container.

The log lives only in browser memory, coalesces progress updates and resets source-specific activity when the selected source changes. Shared archive activity remains visible because it has its own lifetime. No image payloads, endpoints or credentials are placed in the log. The disclosure is collapsed by default to keep imagery space available. These panels add no continuous animation.

Access and Server onboarding

An endpoint with authentication disabled establishes permitted local access automatically, including record reading. Local access · authentication disabled means authorization by configuration; it does not verify a human identity. Each endpoint retains its own policy: an open appliance cannot unlock a protected Server. Protected sources use their normal username/password sign-in page. The application obtains scoped record credentials internally. Successful sign-in is retained separately from stream discovery: temporary catalog pressure shows retrying stream discovery and automatically retries with bounded jitter. Cancel/Escape cancels discovery without discarding the authorized relationship. Permission, certificate and malformed/integrity responses remain explicit errors; they are not treated as busy catalogs. Machine tokens and Server-to-appliance enrollment credentials retain their independent scopes; they are never the browser's normal human login or forwarded to discovered hosts.

Appliance Account & access manages rfSentry-local administrator/read-only accounts, independent of Linux/SSH accounts. Create an administrator before selecting Require sign-in. Account changes, revocation, sign-out and enabling authentication invalidate affected sessions and record readers. Passwords are stored as salted hashes. Appliance browser sessions last eight hours; Server sessions follow their own configured lifetime. Expiry offers sign-in and restores the selected source from recoverable local state. An already explicitly authorized legacy operator tab can complete first-account setup; that migration does not disable its protected policy or invent a human identity. A protected installation with no account and no existing authorization remains locked until an authorized administrator provisions an account.

The appliance's private records.d/browser.json retains UI account/policy settings across restart and upgrades. Existing AUTH_ENABLED values are not rewritten: the UI policy starts from that value, and a subsequently changed host AUTH_ENABLED value takes precedence on restart. Sign out of Server ends the selected Server session independently. A read-only account can consume permitted records but cannot administer accounts, register a new Server on the appliance, or grant a previously unapproved origin on a protected Server.

Native discovery advertises Servers on their configured interfaces and supplies candidates through the appliance's control connection; the browser does not use multicast. Discovery is a hint, not trust or authorization. Use Refresh or Add Server by address for another network. Registrations are stable across reloads, bounded to eight exact HTTPS endpoints and stored privately on the appliance. Names and addresses distinguish multiple Servers; reachability and access are checked when selected.

For a new Server, review an untrusted certificate's fingerprint against the Server's administration identity before accepting it. Native verification still checks validity, endpoint name and the registered Server UUID. The browser must also trust that Server: Browser certificate setup offers its public authority for import through normal browser/OS certificate settings. A successful native check does not bypass browser TLS validation. No origin-file editing, command line credential generation or listener restart is needed for an already permitted source. The Server's permitted session authorizes the exact application origin, while the appliance's verified registration supplies the exact worker CSP origin. TLS, CORS, CSP and cross-origin isolation stay enforced.

Only discovery/authorization metadata goes through the appliance. Bulk archive records flow directly between the browser worker and Server. Reader credentials remain scoped; public source preferences contain no tokens. A reload or detached workspace resumes through the existing permitted relationship. The main window owns the connection and workers; the detached workspace opens no extra SDR or record-reader connection.

Fallback and missing history

Transient network disconnects, interrupted responses, temporary HTTP failures and archive queue pressure automatically reconnect to the same trusted endpoint. The reader resumes from its committed original cursor, retains partial reconstruction, and discards only uncommitted transport read-ahead. It never skips records to reach live. One retry runs at a time with cancellable exponential backoff and jitter: initially 0.5–1 second, increasing to a 15–30 second range. HTTP Retry-After hints are bounded to 30 seconds. Thirty seconds of continuing durably committed forward progress resets the backoff; opening a connection or replaying local state does not. Stop or an applied source switch cancels the pending retry.

The default fallback policy is Keep retrying the Server. The optional Retry and offer appliance fallback policy exposes an explicit action when the Server cannot be reached or lacks the requested original history. Browsers may report network, certificate and CORS failures through the same fetch error, so the UI reports that ambiguity instead of switching silently. Authentication, integrity and configuration failures remain visible and do not qualify for automatic or offered fallback. The workspace header and Configure source show the retry attempt and next scheduled attempt. A no-auth Server restart may invalidate its ephemeral browser ticket; the active reader renews it through the existing permitted session broker. Current Server policy is checked again. A rejected renewal or a second ticket rejection without a verified batch ends that reader attempt. The supervisor rechecks the existing authorization path before another attempt; it cannot bypass protected-mode login or revocation.

Retry now beside the source identity cancels a pending delay and requests one safe attempt. It preserves the journal and product archive. Stop consumption cancels retries and current reading, settling accepted local publication before releasing ownership. Resume consumption restores from committed recovery. This browser remembers enabled/stopped intent across reloads. Switching away from GOES does not stop enabled consumption, and monitoring never changes the appliance job, hardware or receiver settings.

If an attempt fails during checkpoint, storage or reconstruction work, enabled intent stays enabled. After the old owner and accepted publication have settled, the application checks source access and local recovery/storage readiness before starting a fresh reconstruction instance. These recovery retries use exponential backoff with jitter, starting around one second and scheduling at most 15 minutes ahead, with no attempt-count cutoff. Online and browser-resume events wake pending retries. Browser suspension can defer execution until the application resumes.

The HRIT/LRIT header reports the current operation and transfer status. Its operation/progress disclosures show attempt count, next scheduled check and last successful durable progress. Startup & activity and the diagnostic disclosure supply further detail. Known unchanged capacity, integrity or storage blockers receive bounded prerequisite checks rather than repeated expensive reconstruction. Retry now requests a deeper reassessment, still subject to validation and actual storage availability. A stopped source never starts from an automatic retry. An already-due maintenance deadline is retained. One deeper reassessment is allowed per unchanged recovery state/deadline; ordinary prerequisite checks do not continually reload the reconstruction module.

Return to Server history stops the active reader cooperatively, restores the same local reconstruction state, and verifies the Server's hash for the original baseline cursor. If the Server has not archived that cursor, the reader pauses; it does not jump ahead. Source overlap/replay uses original identities and canonical hashes to avoid duplicate products. Distinct original receptions remain separate, including equal payloads.

The live/fallback missing-history policy defaults to Pause and preserve assembly. Selecting Continue available history; mark partials is explicit permission to continue from verified available ranges and publish honest partial products. It cannot invent missing history. Retention expiry and run/configuration/capture boundaries remain visible. Supplemental context precedes dependents without advancing the forward cursor.

Fill retained Server history

On a Server that advertises dated history, Server archive also fills missing browser history using the All products retention settings. For example, 32 GiB / 30 days requests available records from the last 30 days, stopping older backfill when the product byte allowance is reached. Dates use the original first receipt at the Server, not the day the browser imports the records. This is a received-history policy; it does not invent a capture time for undated data.

The browser selects the newest missing ranges first and reconstructs each range in forward order. A separate reader continues receiving new records while older history fills. A fresh browser starts its live reader at the Server's captured tail and obtains the preceding history through the historical reader; the history status remains visible until that work finishes. Live alone describes the forward reader, not a claim that every retained Server record is local. Older Servers retain forward reading and show that dated backfill is unsupported.

Confirmed unavailable ranges in historical backfill are skipped and reported, so an expired interval cannot block the remaining available history. Partial files/images keep loss evidence. Authentication, canonical integrity and configuration errors remain failures. The live/fallback continuation choice still governs the forward reader and is separate from historical gap handling.

When the Server finds a damaged archived record, it can quarantine that known original and report an explicit gap while healthy data continues. Historical backfill requests continuation across these gaps. Errors → Storage identifies the quarantined original and preserves the Server's expected/observed hashes and validation details. The browser does not claim that the damaged canonical bytes passed validation. Browser evidence exports contain surrounding validated inputs; the Server separately retains up to 64 MiB of damaged-frame evidence per archive. Incomplete evidence is labeled. Untrustworthy indexes, missing storage and unavailable configuration dependencies retain their safety restrictions.

The historical-reader status distinguishes catching up, complete, retrying, storage-limited and failed states. Advanced diagnostics show processed ranges, the requested date floor and unavailable ranges. Complete means the available history in the selected dates was processed; it cannot promise reception of missing records. Storage-limited means older data remains on the Server. Increasing the product allowance requests older history again. Newer products take priority when storage is full; one bounded forward range finishes before the historical reader stops, so the newest products within that range can win.

An original-identity ledger and interrupted-range journal survive reloads. Coverage advances only after products and replay state have been saved, and is bound to the local product generation. Live and historical assembly cannot merge incompatible epochs. Bounded subsequent context completes files when available; otherwise the result stays honestly partial. Originals deduplicate by identity and canonical hash, while distinct receptions remain separate observations.

Progress and local recovery

Record mode reports producer RF metrics as unknown when they are not delivered. Its overview shows record delivery and reconstruction rather than an unrelated IQ lane’s lock state or zero-valued RF counters. The source panel separates received, reconstructed, and locally recoverable original positions. Exact 64-bit sequence numbers remain decimal strings/BigInt. Browser ACKs describe local consumption, not Server durability. The Server separately reports its segment/index durable cursor.

The Server supports a negotiated available read view: validated records can reach the browser from bounded Server RAM before their archive commit. Advanced diagnostics show both Server available and durable positions, separately from the browser's reconstructed and locally recoverable positions. Existing durable-only clients keep their original read contract. The accepted baseline includes volatile-tail recovery qualification; available bytes remain distinct from archive durability and cannot authorize acquisition ACKs.

Its normal persistence target is 1 MiB of canonical records, rounded to whole records. There is no default 25-ms or other age-based flush. A configured maximum dirty age is optional; leaving it blank permits a sparse live tail to remain in RAM while immediately readable. Legacy delivery credit, ordered boundaries, cache pressure, explicit drain and clean shutdown may commit smaller groups and report the reason. Only completed segment synchronization and the SQLite FULL commit permit an appliance durability ACK. A separate 16 MiB WAL checkpoint trigger controls index checkpoint work; it is not a hard WAL size limit and does not replace commit durability.

Server administration's storage settings configure these targets. Administrators can explicitly request a stream drain through POST /api/v1/ingestion/drain with streamUuid; a 202 response accepts the request, and the durable cursor reports completion asynchronously. Reading never requests a drain. Normal shutdown drains accepted data within the service stop budget; a failed or timed out drain is logged and cannot generate a durability ACK. If a crash loses a volatile tail, the browser retains its local recovery position while the Server replays original appliance history. Missing history remains an explicit gap.

A dedicated worker validates and reconstructs through shared C++. Browser capability checks prefer native MEMORY64=1; engines without native memory64 automatically use the MEMORY64=2 compatible artifact. Both use the same 64-bit C++ layout, exact BigInt interface and checkpoint format. There is no backend setting or warning for normal compatibility operation. Configure source → Advanced / Diagnostics identifies the selected backend. Live and historical readers use the same selection and retain separate bounded recovery contexts. The resource policy below decides whether those contexts run in separate modules or take turns using one module. Record and product bytes stay off React's thread. Native originals and imagery enter the existing product service, OPFS archive, gallery, native viewer, playback and export paths. Source switching keeps compatible workspace selection and view state. The unchanged direct-IQ reconstruction remains available. Missing OPFS/writable storage, missing ownership support, an occupied stream lock and unsupported WASM capabilities remain distinct failures. Artifact hash/ABI or initialization failures do not silently select another binary.

Compatible addressing is limited to 32-bit linear memory and available device allocations; it does not grant a larger address space. The existing 2-GiB module ceiling is a limit, not a reservation or guarantee that a device can allocate it. Native imagery quality, hot caches and disk-retention policy are unchanged. Safari/iPad reception, reload recovery, imagery, playback and export require device acceptance; local Chromium execution alone does not qualify the device. The pinned compiler remains 4.0.23. Upstream has deprecated mode 2 in newer releases; this is a compatibility bridge, not an SDK migration.

Client resource policy

Configure source → GOES resource policy provides Automatic, Constrained, and Workstation. The choice is a browser-local preference, restored on reload; it does not configure the appliance or Server. WASM backend selection is independent. Lowered memory64, touch support and browser names do not imply weak hardware.

Automatic uses the browser's coarse device-memory hint when available: at least 8 GiB selects Workstation, while lower or unavailable hints select conservative Constrained admission. An unavailable hint is uncertainty, not a free-RAM reading or a diagnosis of weak hardware. Explicit allocation failures latch Automatic to Constrained for the browser session, including reloads. A lost graphics context alone does not establish memory pressure. An explicit override wins.

Workstation retains the existing independent live/historical modules, raster parallelism, 512-MiB compressed / 640-MiB decoded recent-image allowances and 2-GiB automatic native-player budget. Constrained uses a 1,536-MiB managed working-set estimate, 64-MiB compressed / 96-MiB decoded recent-image targets, a 384-MiB automatic native-player budget, and at most 12 speculative recent frames. These affect residency and preparation, not the number of retained observations, loop history, native pixels, scientific precision or export quality. The current native frame remains a required frame rather than becoming a thumbnail. An operation that cannot be admitted reports the selected allowance instead of silently reducing quality. While Constrained is active, the viewer shows its effective automatic cache limit. A previously selected Workstation cache budget stays saved and returns when Workstation is selected; it cannot drive a prefetch/eviction loop against the smaller aggregate allowance.

Constrained live and historical reconstruction keep separate contexts and take bounded 30-second turns in one selected WASM module. Before changing context, dirty native state is published as a checkpoint and manifest, then that instance is released. Unchanged checkpoints are reused. Historical coverage is bound to the same checkpoint so worker replacement can resume the task; its bounded replay log remains available if that checkpoint is rejected. Work waiting for its turn is labeled in Startup & activity, and stale transfer rates are not shown as current retrieval.

Admission counts actual WASM linear-memory capacity, nominal texture/bitmap and compressed cache bytes, queued input buffers, and estimated temporary raster/ checkpoint work. Blob/object-URL storage is conservatively counted alongside retained compressed buffers. Cancelled image work keeps its reservation until it settles or its worker is terminated. Unpinned residency is trimmed before more heavy work is admitted. Interactive work has priority; aging and bounded turns keep history from being starved. The queue is bounded, without extra polling.

WASM capacity remains charged after closing an individual instance: the allocator may reuse it, but the module has not shrunk. When it must be reclaimed, enabled consumption reaches a durable boundary, settles transports/publication and replaces the worker from committed recovery. Automatic reclamation is spaced by at least one minute. Planned retirement does not count as a failed attempt or extend failure backoff. Speculative warming may request it only for an idle owner with capacity substantially above its reported state bounds, after unused caches have been trimmed. A known historical integrity/capacity blocker is retained across automatic replacement; Retry now, an applicable policy change or a new source selection permits reassessment without deleting evidence.

This allowance is not a browser process limit. Browser/driver overhead and other application memory are not fully measurable here, and one native call can grow memory before its resulting capacity is reported. Raster estimates use source geometry and working planes; recovery reserves account for serialized checkpoint size and the existing native state bounds. These controls do not establish iPad stability. Device acceptance must include reception, history, navigation, native playback/export and reload recovery without clearing site data.

Local recovery and configuration evidence

Each original stream has an exclusive browser writer and a checksummed, versioned OPFS replay journal. A commit publishes its manifest only after replay bytes and products are stored. Checkpoints are published before superseded state is retired. Checkpoint save and restore use at most 1 MiB per native/OPFS handoff, with incremental 64 KiB hash updates; they do not hold multiple complete serialized copies of imagery. Existing RFC1 checkpoints and exact product bytes remain compatible. A failed checkpoint preserves the prior snapshot and committed replay inputs, and reports the original checkpoint operation without retrying a trapped native instance. A fresh recovery attempt restores assembly, or replays retained original inputs from a safe earlier boundary; it never infers progress from an uncommitted file tail. Keep browser site data to retain local products and recovery state.

Configuration copies are content-addressed full canonical records. Recovery distinguishes a missing file, a length mismatch and a SHA-256 mismatch, reporting the filename and expected/observed values. It first inspects validated retained replay, at most eight segments per attempt, remembering its scan position across restart. If needed, bounded authenticated dependency reads request exact original positions or retained dependency anchors from the selected source. These reads do not send consumption ACKs, advance the recovery cursor, change receiver settings or substitute a current configuration revision. Both old descriptors identified by full hash and new descriptors carrying original identity are supported; candidates must pass full C++ canonical validation and exact hash/length/source binding before publication. The Server's negotiated available view may supply the exact bytes; local repair does not assert Server durability or request a persistence drain.

A repair reads back the replacement before resuming the committed checkpoint and replay. The first damaged copy is retained in a checksummed diagnostic file (one per configuration, at most 8 MiB of damaged input; larger unexpected files remain untouched for inspection). Successful repair records a recovered incident with its evidence source. New writes are read back before manifest publication, repeated valid configurations can repair a damaged copy, and checkpoint retirement verifies those copies before removing replay redundancy. If exact evidence is unavailable, recovery stays preserved and visibly blocked; unchanged local scans are not repeated, and source rechecks are bounded to at most a 15-minute scheduled interval. Retry now requests an immediate attempt.

OPFS byte writes normalize exact ranges before asynchronous file operations. This protects against the reported Safari/WebKit behavior that writes an entire TypedArray backing buffer instead of its view. A small configuration subarray is copied at its actual length; it is never repaired by truncating the wrong backing buffer. Already-owned, stable full buffers retain their efficient path, and large streamed writes stay bounded and sequential. An oversized copy's “SHA-256 unavailable” means the guarded read was not attempted, not that hashing failed. The diagnostic-preservation ceiling is unchanged.

With Appliance records selected, exact configuration repair may consult an already registered Server through the existing browser session broker. The Server must authorize access without new credentials and its catalog must match the original producer, stream and namespace. Lookup is bounded; discovery is not refreshed and no Server is registered or newly trusted. This borrows only the required configuration evidence: the selected consumption source remains the appliance, normal cursors and ACKs do not advance during repair, and any unavailable normal record history remains an explicit gap. Recovery details show where evidence was sought and whether access or an exact match was missing.

Default bounds are a 4-MiB appliance credit window (up to 4,096 deliveries; legacy appliances retain their 32-delivery ceiling), HTTP pages of at most 512 forward records/4 MiB plus bounded context, and one prefetched HTTP page. Retained recovery targets 2 GiB per selected original stream. In Configure source, Recovery journal ceiling allows 2, 4, 8 or 16 GiB; the default ceiling is 8 GiB. When a real checkpoint/retirement plan still needs more than the target, admission can borrow disk space in 256 MiB increments up to that ceiling. It checks estimated browser quota for the pending publication plus 64 MiB of storage reserve when an estimate is available. Actual OPFS writes remain authoritative. The working allowance shrinks as replay becomes retireable; required inputs are never deleted just to meet a smaller allowance. Lowering the ceiling below required state can block new commits until safe retirement or an operator change makes room. Opening existing recovery does not discard it.

These are disk limits, separate from product archive retention and native/WASM RAM budgets. Normal commits reserve replacement-checkpoint capacity based on a native upper bound without serializing a checkpoint merely to measure it. Checkpoint publication has a separate temporary allowance: up to 544 MiB + 64 bytes for one snapshot, 10 MiB for one input batch and its configuration copies, and 4 MiB for its manifest. The existing manifest is separately bounded to 4 MiB; descriptor count is bounded by the supported replay ceiling and batch packing. An admission-triggered checkpoint can publish its input batch and snapshot together, then retire safe old files. Application capacity and the browser's actual OPFS quota are separate: passing application admission cannot promise free disk space.

Server catch-up advances assembly age using each original's recorded receipt time, including across a fast historical transfer. It does not compress hours of reception into a few minutes of browser wall time. Once the Server confirms its live edge without new originals, measured quiet time can advance expiry. Finite history stays on its recorded timeline. A source without Server receipt timestamps retains the recorded local-receipt fallback; this is not a claimed capture or sensor observation time.

On first recovery from an older forward journal, the browser inspects a compatible checkpoint's actual replay-floor owners, then releases that native instance and replays retained originals with the corrected clock. Startup & activity identifies this one-time replay and shows input counts. The old snapshot remains committed until the corrected replacement is published. Configure source → Advanced / Diagnostics → Prior checkpoint pin before timing repair shows the owner type, original identity, progress, expiry and dependency explanation captured before rebuilding. This is bounded evidence for the current recovery attempt. An unmatched/missing required floor or cursor blocks rebuilding; it does not authorize discarding partial state. No product-archive reset or bulk migration is involved.

Old committed files remain until the new checkpoint and manifest are published. After an uncertain result, a fresh owner reopens and validates committed recovery before cleanup. Existing near-limit journals can reclaim safe replay prefixes without clearing storage. Unmatched replay floors preserve records conservatively and report the mismatch. Incomplete packet buffers expire after 15 minutes without source-time progress, retaining accepted partial file data and loss evidence; file and image expiry policies remain unchanged. C++ separately bounds active file bytes, image bytes including coverage, and queued output at 256 MiB each, with 192 active files and 16 image groups; its memory64 module has a 2-GiB declared memory ceiling. Required replay inputs are never discarded to jump live. Capacity/storage exhaustion ends the current attempt with recoverable progress and enabled intent preserved; unresolved constraints remain visibly blocked while prerequisites are rechecked. These are resource bounds, not thumbnail or downsample substitutions for native product data.

Errors and recovery evidence

The Errors tab records packet/frame, file/codec, history, source-access and storage incidents from decoded-record consumption. Filter by severity, category, source, stream, detection time and recovery outcome; search messages, filenames and original identifiers. Pages contain up to 50 rows, with older/newer controls and Refresh. The detached workspace uses the same parent-owned archive and reader. Browsing errors does not stop consumption or acquire a receiver.

Select an incident for protocol details, original identity/hash, available ASM/Reed–Solomon evidence, configuration/processor identity, affected product and the received/reconstructed/locally recoverable positions at capture. A packet CRC may be not checked when its declared length is unsafe. This is distinct from a failed CRC. Error severity stays visible in the GOES header; full messages are in its issue disclosure and Configure source, with View errors access. Successfully corrected RF symbols and idle packet padding do not generate error incidents.

Transport outages appear as warnings with retrying or recovered outcomes. Their details identify the operation, endpoint path (without credentials or query data), HTTP status/server error code or WebSocket close code when available, retry attempt and delay. The original bounded input excerpt is retained across attempts; recovery updates the same incident rather than inventing another failure. An ambiguous browser fetch failure cannot prove whether the underlying cause was network loss, TLS trust or origin policy.

The shared C++ processor accepts seven-byte CCSDS idle packets (APID 2047) without imposing the HRIT data-packet CRC minimum. A short data packet is rejected and the affected channel waits for a trustworthy packet boundary; rejected CRCs, missing frames, invalid files and codec failures preserve available originals and honest partial/corrupt products. Other channels and later products continue. Canonical integrity/identity conflicts, incompatible configuration, permission failures and exhausted storage/capacity still block reading explicitly. Enabled intent permits prerequisite rechecks, never bypassing those blockers. Continuing does not imply that missing bytes were recovered.

Checkpoint incidents use checkpoint-save in the storage category. Their details distinguish application capacity, OPFS quota and I/O failure, and include retained bytes, old/replacement checkpoint sizes, limits, headroom, replay floor and safely retireable bytes. Repeated identical failures coalesce; existing incident/evidence retention bounds still apply.

Incident metadata is indexed in a worker; bounded original-input excerpts are stored in OPFS before the corresponding replay commit and browser ACK. The processor revision is rfsentry-hrit-records-2; older checkpoints are replaced through retained-input replay, preserving the existing recoverable cursor rules. Replay groups the same incident identity rather than duplicating rows. Older products retain their original processor provenance.

Defaults retain at most 2,000 incident entries and 64 MiB of evidence, with at most 2 MiB per incident (one additional bounded file may be staged during publication). Metadata is bounded to 16 KiB per entry. Retention evicts oldest incidents, reports eviction totals and does not delete product originals or the required stream recovery journal. Individual native operations retain up to 16 detailed incidents; an explicit aggregate notice records omitted detail counts.

Export incident evidence downloads an .rfe file: RFE1, two big-endian 32-bit lengths (JSON metadata and replay payload), then UTF-8 JSON and the checksummed RFL1 input excerpt. Export rechecks the stored evidence hash. Missing or changed evidence is reported unavailable instead of being exported as verified. Excerpts include retained configuration and a bounded preceding-record window; earlier assembly may still require archived history, so incomplete context is labeled explicitly. They are not raw IQ and contain no browser/service credentials. The export is operator-controlled; nothing is uploaded automatically.