JavaScript runtime

STATIC’s browser runtime applies the selected profile to defined JavaScript-visible observations in eligible documents and fetched worker contexts. Rust embeds the generated bundles and coordinates delivery. The browser performs the underlying operations: changing an observation does not replace its engine, GPU, devices, codecs or permissions.

The operator controls the presented profile. Protection aims to reduce exposure of native identifying information; a different value or hash alone does not establish anonymity, host-independent rendering or resistance to recognition.

Overview and source map

The Window entry is runtime.js. Profile anatomy explains inputs; HTML injection and CSP explains delivery. Defined observations are distinct from universal browser emulation.

How the script reaches a page

Eligible HTML receives a reference to STATIC’s locally served /__static/runtime.js. A UTF-8 configuration carrier supplies the effective browser policy. The runtime copies, validates and freezes that input, then consumes the carrier. Declared settings are not secret storage; original API handles and runtime services remain private.

Response eligibility and browser execution are separate. Unsupported content, encoding, restrictive policy, an unproxied response or earlier code can leave a context uncovered. Fetched workers use their own response-bootstrap path, not the DOM-dependent Window entry.

Bootstrap order and shared state

Runtime state belongs to a bundle closure in each initialized realm. There is no supported page-facing registry or original-method interface. Captured invocation, descriptor and bookkeeping helpers avoid routing private API handles through page-replaced helper functions. Capture must precede hostile code; this does not isolate every engine-internal callback or clean realm.

Configuration is data-only, bounded and validated before API mutation. Profile, originals, nonce, entropy and policy initialize once within the retained runtime. A retry rolls back and retries failed reversible modules while retaining successful patches and their original state.

Installers are synchronous. Descriptor journals support nested rollback; later listeners, timers, maps and pending normalizers need their own lifetime/disposal ownership. Disposed installations reject owned continuations rather than apply stale normalization. Realm teardown respects back-forward cache persistence. Neither a journal nor disposal can atomically undo arbitrary browser operations.

Outcomes distinguish installed, partial, native, disabled, unavailable and failed surfaces. Entry-point readiness and coverage are separate from target parity or effective privacy. Genuine interfaces preserve receiver checks, descriptor ownership/setters and appropriate return types; function appearance alone does not hide interception.

Timing and race boundaries

The HTML scanner chooses insertion positions outside recognized comments, raw text and inert/foreign content. It is not a complete HTML parser or control over every preload, service-worker cache or early child script. Reachable frame access, observation and load hooks attempt own-realm initialization; a script path cannot suppress fallback or prove execution.

CSP, Trusted Types, origin restrictions and early execution can prevent or precede fallback. Independently delivered bundle copies do not have an authenticated ownership protocol. Treat coverage as realm- and response-dependent. See delivery prerequisites.

Identity: navigator and Client Hints

Existing interfaces expose configured user agent, app version, platform, vendor, languages, concurrency, memory and touch observations. Covered UA-data results map architecture, bitness, model, platform version, full versions, WoW64 and string-array form factors. Output copies do not expose mutable configuration, and unhandled native identity fields are not automatic passthrough.

A Firefox persona suppresses Chromium UA-data acquisition on hosts with that surface and neutralizes covered retained objects. Genuine Firefox does not acquire an invented Chromium interface. Optional API presence and engine semantics remain observable; same-family targets provide the most coherent starting point.

The Rust header stage coordinates supported HTTP hints with the effective profile, including requests after Accept-CH. Request headers explains that independent request path. Identity strings do not implement another engine. Source: navigator.js.

Screen, fonts, and time zone

Screen, orientation, pixel ratio and configured viewport observations follow supported profile controls. Actual CSS/layout, VisualViewport, zoom, resize and scheduling can disagree. Fixed focus/visibility queries do not create a virtual foreground state or scheduler.

Font protection applies deterministic perturbation to selected element metrics; equal content/measurements do not depend on unrelated read order. With configured fonts, font_inventory_policy can restrict FontFaceSet.check() queries to the declared families and generic fallbacks. It does not install fonts, replace glyphs, or normalize canvas/SVG/TextMetrics/font-loading behavior. Explicit native font-query policy opts out of that restriction.

Covered local Date fields, setters, numeric construction, strings, locale methods and default Intl formatting use the selected zone with DST-aware conversion. UTC operations and explicit application zones retain their requested meaning. Intl options use a facade that supports frozen option objects. timezone_legacy_policy controls nonstandard local parsing: normalization where supported, explicit denial, or a native opt-out. Historical grammar and extreme dates/setters remain contract boundaries; no OS clock/time-zone setting is changed.

Sources: screen, fonts, timezone.

Plugins and MIME types

Plugin/MIME observations describe standardized PDF compatibility rather than arbitrary installed extensions. pdf_inventory_policy: standardized-native normalizes genuine matching browser collections; unmatched acquisition can throw SecurityError. A disabled viewer profile exposes genuine empty collections only on hosts with those collections; it otherwise denies collection acquisition. deny uniformly restricts collection getters while retaining the configured viewer flag where supported.

Neither mode supplies branded collections absent from the host or controls actual PDF navigation. Restriction can affect feature detection and differs from complete cross-host viewer emulation. Source: plugins.js.

Canvas fingerprinting mitigation

Covered 2D readback/export paths include getImageData, toDataURL, toBlob and applicable OffscreenCanvas/bitmap extraction. Exports use private copies without repainting the application’s source. Ordinary image, Blob, ImageBitmap and ImageData decoding remains native.

canvas_readback_mode: noise applies the selected intervention but can retain enough native structure for approximate recognition or repeated-query recovery. redacted returns a fixed configured color on covered paths, discarding image content. Redaction is a destructive privacy restriction, not reference rendering or whole-browser parity.

Canvas export budgets bound estimated extra bytes and concurrent work. Settings are snapshotted at invocation; intermediates release after success/failure or owned teardown. Exhaustion rejects explicitly rather than returning a large unmasked result. Accounting is not a measured heap/GPU peak. Color/alpha, floating formats, taint, transfer, native conversion/failure timing and concurrency require their own validation. Source: canvas.js.

WebGL fingerprinting mitigation

Genuine WebGL 1/2 interfaces expose separate configured metadata, limits, typed parameters, precision observations and extension lists. An explicit enum contract resolves core and extension-owned parameters; unknown, version-invalid or conflicting declarations reject before installation. Covered parameter observations retain native receiver/context validation without host-limit clamping or native-null substitution. Lost contexts keep their genuine behavior.

Declared observations do not implement another driver. Missing real extensions may return null; allocation, errors, shaders, readPixels, rendering and timing remain native. Precision normalization also depends on genuine result interfaces. Validate advertised metadata and actual operation separately. Source: webgl.js.

Audio fingerprinting mitigation

Explicit audio settings take precedence over resolved hardware/defaults. Destination metadata is scoped to genuine destinations; unrelated nodes retain ordinary inputs/outputs and channel setters. Oscillator intervention preserves native start validation, including zero-frequency input, and application automation remains operational. Offline buffers are transformed once across promise/event access; covered float/byte analyser paths leave unused output slots untouched.

Reported metadata and real engine parameters differ: explicit native rates, buffers, timestamps and audible output are not universally emulated. audio_context.worklet_policy chooses broad floating-output masking, structured channel-data handling or explicit opaque-message denial. Recognized payload copying is bounded; arbitrary floating controls can resemble audio under the broad policy. Window-side message handling does not protect processor globals or every opaque/transferable route.

Protection can affect sound and timing. Module enablement follows profile settings rather than website exceptions. Source: audio.js.

WebRTC and media devices

WebRTC combines observation masking with an explicit transport policy. Default relay-only transport requires caller-configured TURN infrastructure; no relay can mean no connection. STATIC does not create TURN, change the proxy’s public IP or route every browser transport through its listener.

Description translations belong to the peer, description type and ICE generation. Ambiguous aliases reject; close/restart/rollback disposes owned history, and entry/byte budgets bound retention. Returned-object ownership and copied/serialized inputs have separate checks. Expired or foreign local descriptions do not silently select another connection’s native data.

webrtc_observation_policy: mask-all rewrites covered primary/related candidate and statistics addresses, including relay endpoints, and can make remote signaling unusable. preserve-relay-routing requires relay-only and retains usable TURN primary endpoints while masking related device addresses. Relay infrastructure is therefore visible under that explicit contract. Real two-peer bidirectional traffic remains a separate requirement; no-TURN denial alone does not demonstrate working protected communication.

Media devices retain genuine objects with profile count filters, per-device labels and opaque ID/group aliases. Omitted/zero configured kinds stay excluded; nested advanced constraints are translated and masked recursively. Unknown aliases reject rather than fall back to native IDs. State is bounded for the realm’s lifetime and disposed at teardown; aliases cannot be assumed usable in another frame. Physical absence, capability ranges, events, permission timing and full virtual topology remain partial.

Sources: WebRTC, media devices.

Capabilities: permissions and device APIs

Present battery/network/permission interfaces remain genuine and expose covered profile observations with native receiver validation. Absent APIs stay absent. Trusted backend transitions are suppressed on covered fixed-state paths; application-dispatched events retain their ordinary route. This is not a full event model: earlier listeners, grants, operations, throttling and physical conditions can disagree with fixed observations.

Storage estimates return fixed profile quota/usage independent of native disk measurements or writes. Backend detail is omitted; actual persistence, OPFS and allocation/exhaustion remain browser operations. Advertised storage covers overrides.

Finite media policy coordinates covered MediaCapabilities, canPlayType() and MediaSource support observations. Native validation and genuine DRM/operation failures remain. Positive reports do not supply codecs; WebCodecs/RTP/complete encrypted-media consistency is outside that finite matrix. Read the capability modules with the schema contract.

Speech, gamepads, performance, and event timing

Speech exposes a bounded set of genuine local voices with configured metadata and usable selection. Voice absence, loading and audible behavior remain native. Gamepad identifiers change on genuine controllers; null slots, topology, input, haptics and events retain their operation.

Selected performance/event observations and serialization share monotonic coarsening. Counters and byte sizes retain their meaning. Other clocks, scheduling and throughput are not virtualized. Timing protection follows profile flags, not hostname exceptions. Sources: spoofing, identity.

Workers and same-origin iframes

Worker constructors retain native URLs, options and sharing. Eligible fetched responses bootstrap at their original URLs through separate classic/module entries; required module dependencies must be admitted by policy. Worker coverage does not assume a DOM or duplicate all Window surfaces.

Present worker identity, capabilities, timing, timezone and applicable Offscreen 2D/WebGL observations follow the delivered policy. Selected canvas inputs are preserved, with realm-specific output state. Frames capture their own originals/state; cross-origin/sandbox parent access may be unavailable. Complete early/non-network protection needs browser-level integration, outside this proxy-only design. Sources: contexts, delivery stage.

Automation, geolocation, and selective blocking

Automation changes covered markers/queries without creating a fictional browser namespace. Geolocation denies covered paths rather than inventing coordinates; native browser-policy enforcement and fallback errors vary by engine. OS permission settings are separate.

URL rules suppress selected fetch/beacon/XHR paths, not every transport. Blocked XHR uses generation identity and timer cancellation, checking after callbacks so abort/reopen cannot continue stale success events. Body/header/upload/timeout and complete native event conformance remain partial. Timers and listeners have bounded ownership/cleanup.

The Rust behavioral stage is distinct from the injected fingerprint runtime. The standalone behavioral payload shim is not a normal bundle component or supported protection path. Sources: evasion, privacy, behavioral stage.

Entropy, stability, and limits

Private context-scoped variation is distinct from the resolved profile. Public labels are not secret keys or promised output hashes. Stable observations do not establish coordinated identity across realms, origins or visits; actual rendering and uncovered probes can retain native structure.

Source tests/builds, native contract tests, actual proxy delivery, remote connectivity and privacy measurements answer different questions. CI separates source/profile, Rust, browser, live-proxy and rendering-effectiveness jobs. Effectiveness gating is enabled in its dedicated job; default sparse noise can fail approximate recognition even when functional contracts pass. A configured job does not prove a run or branch-required enforcement. Target parity, recovery, detectability and linkability require separate evidence.

For diagnosis, check injection eligibility, selected profile and explicit controls. Navigate/reload after selection changes: existing realms retain frozen policy. CA and trust and platform guides cover routing/trust prerequisites independently.