Client-Side Execution Architecture: Privacy-Preserving Variance Computation on Device

Mechanism

The client-side execution architecture is the embodiment in which the complete content-identity pipeline runs inside a standard browser execution context, without server-side infrastructure, GPU compute, or a per-query API service. The content input stage receives a file object or media stream from a standard browser file input or media capture API. From that input through unique identifier (UID) computation, local similarity evaluation, and anchor query dispatch, every stage executes within the browser. The raw content artifact does not leave the client device during the admissibility evaluation phase: only the computed UID and the resulting admissibility decision are transmitted.

This is a placement of the disclosed pipeline, not a different algorithm. The same multi-scale variance analysis, the same 27-dimensional vector construction, the same 320-bit UID, and the same cosine-similarity comparison disclosed for the platform are expressed in the arithmetic primitives the browser provides. The cost and privacy posture of content anchoring change with where the computation happens, while the UID and admissibility semantics remain identical to a server-side execution of the same pipeline.

Normalization on the Canvas 2D API

The Canvas 2D API normalization module performs canonical resizing, grayscale conversion, and orientation canonicalization using only the standard HTMLCanvasElement and CanvasRenderingContext2D interfaces available in any conforming browser, without WebGL, WebAssembly, or server-side dependency. This is the canonical preparation disclosed elsewhere in the specification: the artifact is rescaled to the canonical square canvas, converted to a grayscale field, and, where its dominant gradient orientation exceeds the canonicalization threshold, rotated about the center of the canvas so that predominant orientation structure is presented in a consistent spatial frame prior to spatial decomposition.

Confining normalization to the Canvas 2D interfaces is what makes the client-side path portable across conforming browsers without auxiliary runtimes. Because the same canonical preparation is produced regardless of host, a UID computed in the browser corresponds to a UID computed for the same artifact on any other conforming node.

Client-Side Variance Vector and UID Computation

The client-side variance vector computation module performs multi-scale variance analysis, gradient histogram computation, and 27-dimensional vector construction using standard JavaScript arithmetic operations. The client-side hash module then produces a 320-bit UID by applying the multi-scale FNV-variant hash combiner in standard JavaScript. These are the same extraction and hashing operations disclosed for the platform, carried out in the browser rather than requiring native or accelerated compute.

Because the identifier encodes a position in a continuous variance space, the comparison the client needs is cosine similarity computed directly from the UID without decoding a binary digest. This is why the evaluation can run client-side at all: there is no embedding model to invoke and no centralized index to query in order to compare two artifacts.

Local Similarity Evaluation

The local similarity evaluation module computes cosine similarity against a locally cached exclusion corpus fragment and evaluates the result against a locally stored policy object. The locally cached exclusion corpus fragment is a slope-band-filtered subset of the full governed corpus, pre-fetched from the anchor network for the variance bands most likely to be relevant to the content categories the client is authorized to process. The locally stored policy object is a versioned, signed policy object pre-fetched from the governing authority under which the client operates.

Both the corpus fragment and the policy object are verifiable by their cryptographic signatures without requiring a live connection to the anchor network at evaluation time. This enables client-side admissibility evaluation in disconnected or intermittently connected environments, with the assurance that the policy object and corpus fragment are authentic and unmodified, so the client can proceed to evaluate without a round trip.

Anchor Query Dispatch

The anchor query module transmits only the computed UID to the anchor network for corpus-scale resolution, rather than transmitting the raw artifact. The complete pipeline from content input through UID computation, local similarity evaluation, and anchor query dispatch executes within the browser, and only the computed UID and the resulting admissibility decision are emitted. Resolution beyond the locally cached fragment is obtained by submitting the candidate UID to the anchor cluster governing its variance band, consistent with the UID resolution query protocol, in which a querying party submits a candidate UID computed locally without transmitting the artifact itself.

Properties That Follow From On-Device Placement

Two properties follow from running the pipeline on the client. First, data minimization: because the raw content artifact does not leave the client device during the admissibility evaluation phase, the architecture conforms to data minimization requirements that restrict transmission of personal media content. Second, decoupled cost: because similarity evaluation operates over variance-derived UIDs rather than requiring GPU inference or a centralized embedding index, admissibility can be executed client-side, at upload time, and avoids per-query inference costs proportional to content volume.

The specification states these as consequences of the placement and of the embedding-free nature of the variance-derived UID. It does not assert a fixed transmitted-record size beyond the 320-bit UID construction described above, and this article makes no claim about transmission size beyond the UID itself.

Distinction From Conventional Approaches

Generative systems evaluate admissibility through post-generation moderation filters applied after an output artifact has been produced, which cannot prevent impermissible content from existing as an internal artifact. Watermarking and metadata tagging attach identity signals that are removable through transcoding, cropping, or generative reconstruction, or that are decoupled from content structure and require persistent external storage. The client-side execution architecture instead evaluates admissibility before commitment, using a structurally derived UID computed from the content itself on the client. Nothing is embedded in the artifact and no live central registry is consulted at evaluation time, which is what allows the evaluation to be both pre-release and computed on the device.

Disclosure Scope

The client-side execution architecture, comprising content input from a standard browser file input or media capture API, Canvas 2D API normalization using only HTMLCanvasElement and CanvasRenderingContext2D without WebGL, WebAssembly, or server-side dependency, client-side multi-scale variance analysis, gradient histogram computation, and 27-dimensional vector construction in standard JavaScript, client-side 320-bit UID construction via the multi-scale FNV-variant hash combiner, local similarity evaluation against a locally cached, signature-verifiable slope-band-filtered exclusion corpus fragment and a locally stored signed policy object, and an anchor query module that transmits only the computed UID rather than the raw artifact, is disclosed in support of PCT International Application No. PCT/US26/28630. This article describes that disclosed embodiment. The scope extends to deployment in disconnected or intermittently connected environments in which the corpus fragment and policy object are verified from their cryptographic signatures without a live connection at evaluation time, provided the raw content artifact does not leave the client device during the admissibility evaluation phase and only the computed UID and admissibility decision are transmitted.