Package-level declarations

Attempts independent render-thread GUI cleanup without retaining callbacks, handles or queues after return. Every cleanup is attempted even when an earlier one fails, without waiting for GPU work.

Orders borrowed owner-thread Canvas shutdown before the platform destroys its rendering context. Screen failures do not skip queue discard or vanilla shutdown; device release requires a successful discard. An original vanilla failure remains primary over independent cleanup failures.

Registers Strata overlays through the selected official Fabric HUD API.

Version-owned capability for dropping queued GUI references without submitting native draws. Native GUI owners implement this through typed Mixins; calls belong to the render thread and retain no resources after return.

Connects native GUI consumption and device lifetime on the client/render thread without owning screen or resource references. A native operation's original failure remains primary when independent Canvas cleanup also fails.

Fabric client screen backed by one common Minecraft UI host.

Owns one bounded opaque Strata frame, independently of caller arrays and borrowed native codec buffers. Identity remains per payload; every returned byte array is detached from its storage.

Native custom-payload endpoint shared by all supported Fabric clients. Client extensions register their factories before the first play connection captures registry. Network callbacks enqueue only owned bytes; all session and rendering work runs on the client tick thread.

Registers the selected native payload directions and transports authenticated opaque Strata frames.

Registers Fabric's typed client receiver and sends copied Strata fragments on the current play connection.

Client-thread input bridge using current native mappings and vanilla gameplay handlers.

Client-thread ownership of native wrappers; every entry has one common retained host for its entire lifetime.

Exposes physical Vulkan texture or view destruction without exposing a native handle. The render thread borrows this Mixin-provided capability while its Canvas owner retains the resource until acknowledgement.

Borrows an offscreen target and command encoder for one render-thread Canvas callback.

Owns custom native drawing resources for one attachment resource generation.

Borrows one ordinary 2D RGBA8 straight-alpha color texture until GPU capture completion.

Identifies which logical image edge contains native texel row zero.

Supplies an externally owned native color image for an actual Canvas presentation.

Server-owned UI entry point for dedicated and integrated Fabric servers. Operations require the server thread after Fabric emits SERVER_STARTED; async callers must schedule there first. Create mutable state inside open's factory and keep it on that server's execution owner.

Registers networking and logical-server lifecycle on either physical environment.

Fabric client entrypoint that installs the process-wide Strata screen presenter.

Committed lifecycle notifications emitted inside the service's execution owner. Notifications run on the server thread; listener failures never undo committed state. UI identity is scoped to the service and connection. Capability and presentation values are snapshots; player, owner Mod, and session references retain their native ownership.

Describes an externally owned GPU image provider without acquiring a texture or allocating native storage.

Describes a custom offscreen renderer without invoking its factory or allocating native storage.

Compatibility factory sharing the common UI host path.

Creates a Fabric client screen by transferring definition into one independent common host.

Extracts the complete Minecraft UI profile from the active resource manager.

Snapshots the current client's selected 64 by 64 player skin for portable PlayerHead rendering.

Loads one immutable UI image from the active resource manager.