tiny.wayland.runtime

1pub const Capacity = struct {2    transport: wayland.TransportCapacity,3    request_encoder: wayland.protocol.value.EncoderCapacity,4    event_storage: event.Capacity,5    event_creations: creation.Capacity,6    client_ids: wayland.ids.Capacity,7    objects: object_model.Capacity,8    globals: global_state.Capacity,9    total_requested_bytes: usize,1011    pub fn derive(limits: Limits) CapacityError!Capacity {12        const transport = try wayland.TransportCapacity.derive(limits.transport);13        const request_encoder = try wayland.protocol.value.EncoderCapacity.derive(.{14            .payload_byte_count = @min(15                transport.outbound_byte_count - wayland.wire.header_size,16                wayland.protocol.value.maximum_payload_size,17            ),18            .descriptor_count = @min(19                transport.outbound_descriptor_count,20                sys.ancillary.maximum_descriptors,21            ),22        });23        const event_storage = try event.Capacity.derive(.{24            .payload_byte_count = @min(25                transport.inbound_byte_count - wayland.wire.header_size,26                wayland.protocol.value.maximum_payload_size,27            ),28            .descriptor_count = @min(29                transport.inbound_descriptor_count,30                event.maximum_descriptor_count,31            ),32        });33        const event_creations = creation.default_capacity;34        const client_ids = try wayland.ids.Capacity.derive(.{35            .client_id_count = limits.client_object_count,36        });37        const objects = try object_model.Capacity.derive(.{38            .client_object_count = limits.client_object_count,39            .server_object_count = limits.server_object_count,40        });41        const globals = try global_state.Capacity.derive(.{42            .retained_global_count = limits.retained_global_count,43            .interface_name_byte_count_per_global = limits.global_interface_name_byte_count,44        });45        const total_requested_bytes = try totalRequestedBytes(&.{46            transport.total_requested_bytes,47            request_encoder.total_requested_bytes,48            event_storage.total_requested_bytes,49            event_creations.total_requested_bytes,50            client_ids.total_requested_bytes,51            objects.total_requested_bytes,52            globals.total_requested_bytes,53        });54        return .{55            .transport = transport,56            .request_encoder = request_encoder,57            .event_storage = event_storage,58            .event_creations = event_creations,59            .client_ids = client_ids,60            .objects = objects,61            .globals = globals,62            .total_requested_bytes = total_requested_bytes,63        };64    }65};

1pub const Client = struct {2    transport: wayland.Transport,3    catalog: catalog_model.Catalog,4    ids: wayland.ids.Pool,5    objects: object_model.Table,6    globals: global_state.Set,7    encoder: wayland.protocol.value.Encoder,8    event_storage: event.Storage,9    event_creations: creation.Storage,10    fatal_state: ?event.FatalView = null,11    terminal_error: ?anyerror = null,1213    pub fn connect(14        session_allocator: std.mem.Allocator,15        capacity: Capacity,16    ) !Client {17        var initial_storage = try InitialStorage.init(session_allocator, capacity);18        errdefer initial_storage.deinit();19        const transport = try wayland.connect(session_allocator, capacity.transport);20        return initOwnedParts(transport, &initial_storage);21    }2223    pub fn connectNamed(24        session_allocator: std.mem.Allocator,25        display_name: []const u8,26        capacity: Capacity,27    ) !Client {28        var initial_storage = try InitialStorage.init(session_allocator, capacity);29        errdefer initial_storage.deinit();30        const transport = try wayland.connectNamed(31            session_allocator,32            display_name,33            capacity.transport,34        );35        return initOwnedParts(transport, &initial_storage);36    }3738    pub fn initOwned(39        session_allocator: std.mem.Allocator,40        owned_descriptor: sys.fd.Descriptor,41        capacity: Capacity,42    ) !Client {43        var initial_storage = InitialStorage.init(session_allocator, capacity) catch |err| {44            sys.fd.close(owned_descriptor);45            return err;46        };47        errdefer initial_storage.deinit();48        const transport = try wayland.Transport.initOwned(49            session_allocator,50            owned_descriptor,51            capacity.transport,52        );53        return initOwnedParts(transport, &initial_storage);54    }5556    fn initOwnedParts(57        transport: wayland.Transport,58        initial_storage: *InitialStorage,59    ) Client {60        const catalog = catalog_model.Catalog.standard();61        const client: Client = .{62            .transport = transport,63            .catalog = catalog,64            .ids = initial_storage.ids,65            .objects = initial_storage.objects,66            .globals = initial_storage.globals,67            .encoder = initial_storage.encoder,68            .event_storage = initial_storage.event_storage,69            .event_creations = initial_storage.event_creations,70        };71        initial_storage.* = undefined;72        return client;73    }7475    pub fn deinit(self: *Client) void {76        self.event_creations.deinit();77        self.event_storage.deinit();78        self.encoder.deinit();79        self.globals.deinit();80        self.objects.deinit();81        self.ids.deinit();82        self.transport.deinit();83        self.* = undefined;84    }8586    pub fn fatal(self: *const Client) ?event.FatalView {87        const state = self.fatal_state orelse return null;88        return .{89            .object_id = state.object_id,90            .code = state.code,91            .message = state.message,92        };93    }9495    pub fn descriptor(self: *const Client) sys.fd.Descriptor {96        return self.transport.descriptor;97    }9899    pub fn storageStatus(self: *const Client) StorageStatus {100        return .{101            .transport = self.transport.status(),102            .request_encoder = self.encoder.status(),103            .event_storage = self.event_storage.status(),104            .event_creations = self.event_creations.status(),105            .client_ids = self.ids.status(),106            .objects = self.objects.status(),107            .globals = self.globals.status(),108        };109    }110111    pub fn object(self: *const Client, id: u32) ?object_model.Entry {112        return self.objects.getLive(id);113    }114115    pub fn global(self: *const Client, registry_id: u32, name: u32) ?event.GlobalView {116        const item = self.globals.get(registry_id, name) orelse return null;117        return .{118            .registry_id = item.registry_id,119            .name = item.name,120            .interface = item.interface,121            .version = item.version,122        };123    }124125    pub fn sync(self: *Client) !u32 {126        var created: [1]u32 = undefined;127        try self.request(128            wayland.ids.display_id,129            0,130            &.{.{ .new_id = .fixed }},131            &created,132        );133        return created[0];134    }135136    pub fn getRegistry(self: *Client) !u32 {137        var created: [1]u32 = undefined;138        try self.request(139            wayland.ids.display_id,140            1,141            &.{.{ .new_id = .fixed }},142            &created,143        );144        return created[0];145    }146147    pub fn bind(148        self: *Client,149        registry_id: u32,150        name: u32,151        interface: *const wayland.protocol.schema.Interface,152        version: u32,153    ) !u32 {154        try self.ensureActive();155        const registry_interface = try self.catalog.require("wl_registry");156        const registry = try self.objects.requireLive(registry_id);157        if (registry.interface != registry_interface) return error.NotRegistry;158        const canonical = try self.catalog.canonical(interface);159        const advertised = try self.globals.require(registry_id, name);160        if (!std.mem.eql(u8, advertised.interface, canonical.name)) {161            return error.InterfaceMismatch;162        }163        if (version == 0 or version > advertised.version or version > canonical.version) {164            return error.InvalidVersion;165        }166167        var created: [1]u32 = undefined;168        try self.request(169            registry_id,170            0,171            &.{172                .{ .uint = name },173                .{ .new_id = .{ .dynamic = .{174                    .interface = canonical.name,175                    .version = version,176                } } },177            },178            &created,179        );180        return created[0];181    }182183    pub fn request(184        self: *Client,185        object_id: u32,186        opcode: u16,187        values: []const request_model.Value,188        created_ids: []u32,189    ) !void {190        try self.ensureActive();191        const parent = try self.objects.requireLive(object_id);192        const metadata = parent.interface.request(opcode) orelse {193            return error.UnknownRequestOpcode;194        };195        if (!metadata.supportedBy(parent.version)) return error.UnsupportedRequestVersion;196        if (metadata.destructor and parent.origin == .display) return error.CannotDestroyDisplay;197198        const prepared = try request_model.prepare(199            &self.ids,200            &self.objects,201            self.catalog,202            &self.encoder,203            parent,204            metadata,205            values,206            created_ids,207        );208        errdefer request_model.rollback(&self.ids, &self.objects, prepared.created_ids);209        try self.transport.queueOwned(210            object_id,211            metadata.opcode,212            prepared.encoded.payload,213            prepared.encoded.descriptors,214        );215        if (metadata.destructor) {216            lifecycle.retire(217                &self.ids,218                &self.objects,219                object_id,220                parent,221                .retired_request,222            );223        }224    }225226    pub fn flush(self: *Client) !wayland.stream.FlushStatus {227        try self.ensureActive();228        return self.transport.flush() catch |err| {229            self.terminal_error = err;230            return err;231        };232    }233234    pub fn step(self: *Client) !event.Step {235        try self.ensureActive();236        self.event_storage.reset();237        return dispatch.step(self);238    }239240    fn ensureActive(self: *const Client) !void {241        if (self.terminal_error) |err| return err;242    }243};

1pub const Limits = struct {2    transport: wayland.TransportLimits = .{},3    client_object_count: usize = object_model.default_client_object_count,4    server_object_count: usize = object_model.default_server_object_count,5    retained_global_count: usize = global_state.default_retained_global_count,6    global_interface_name_byte_count: usize =7        global_state.default_interface_name_byte_count_per_global,8};

1pub const StorageStatus = struct {2    transport: wayland.TransportStatus = .{},3    request_encoder: wayland.protocol.value.EncoderStatus = .{},4    event_storage: event.Status = .{},5    event_creations: creation.Status = .{},6    client_ids: wayland.ids.Status = .{},7    objects: object_model.Status = .{},8    globals: global_state.Status = .{},9};

1pub const Capacity = struct {2    payload_byte_count: usize,3    descriptor_count: usize,4    descriptor_bytes: usize,5    total_requested_bytes: usize,67    pub fn derive(limits: Limits) CapacityError!Capacity {8        if (limits.payload_byte_count > wayland.protocol.value.maximum_payload_size) {9            return error.EventPayloadStorageTooLarge;10        }11        if (limits.descriptor_count > maximum_descriptor_count) {12            return error.EventDescriptorStorageTooLarge;13        }14        const descriptor_bytes = std.math.mul(15            usize,16            limits.descriptor_count,17            @sizeOf(sys.fd.Descriptor),18        ) catch return error.CapacityOverflow;19        const total_requested_bytes = std.math.add(20            usize,21            limits.payload_byte_count,22            descriptor_bytes,23        ) catch return error.CapacityOverflow;24        return .{25            .payload_byte_count = limits.payload_byte_count,26            .descriptor_count = limits.descriptor_count,27            .descriptor_bytes = descriptor_bytes,28            .total_requested_bytes = total_requested_bytes,29        };30    }31};

1pub const CapacityError = error{2    EventPayloadStorageTooLarge,3    EventDescriptorStorageTooLarge,4    CapacityOverflow,5};

1pub const EventView = union(enum) {2    fatal: FatalView,3    delete_id: u32,4    callback_done: CallbackDone,5    global: GlobalView,6    global_remove: GlobalRemoved,7    routed: message.RoutedView,8};

1pub const GlobalView = struct {2    registry_id: u32,3    name: u32,4    interface: []const u8,5    version: u32,6};

1pub const Limits = struct {2    payload_byte_count: usize = wayland.protocol.value.maximum_payload_size,3    descriptor_count: usize = maximum_descriptor_count,4};

1pub const Status = struct {2    event_payload_capacity_rejection_count: u64 = 0,3    event_descriptor_capacity_rejection_count: u64 = 0,4};

1pub const Step = union(enum) {2    event: EventView,3    pending,4    closed,5};

1pub const Storage = struct {2    session_allocator: std.mem.Allocator,3    payload: []u8,4    descriptors: []sys.fd.Descriptor,5    payload_count: usize = 0,6    descriptor_count: usize = 0,7    payload_capacity_rejection_count: u64 = 0,8    descriptor_capacity_rejection_count: u64 = 0,910    pub fn init(11        session_allocator: std.mem.Allocator,12        capacity: Capacity,13    ) std.mem.Allocator.Error!Storage {14        const payload = try session_allocator.alloc(u8, capacity.payload_byte_count);15        errdefer if (payload.len != 0) session_allocator.free(payload);16        return .{17            .session_allocator = session_allocator,18            .payload = payload,19            .descriptors = try session_allocator.alloc(20                sys.fd.Descriptor,21                capacity.descriptor_count,22            ),23        };24    }2526    pub fn deinit(self: *Storage) void {27        self.reset();28        if (self.payload.len != 0) self.session_allocator.free(self.payload);29        if (self.descriptors.len != 0) self.session_allocator.free(self.descriptors);30        self.* = undefined;31    }3233    pub fn reset(self: *Storage) void {34        self.assertValid();35        for (self.descriptors[0..self.descriptor_count]) |descriptor| {36            if (descriptor >= 0) sys.fd.close(descriptor);37        }38        self.payload_count = 0;39        self.descriptor_count = 0;40        self.assertValid();41    }4243    pub fn admit(44        self: *Storage,45        payload_byte_count: usize,46        descriptor_count: usize,47    ) StorageError!void {48        self.assertValid();49        std.debug.assert(self.payload_count == 0);50        std.debug.assert(self.descriptor_count == 0);51        var failure: ?StorageError = null;52        if (payload_byte_count > self.payload.len) {53            self.payload_capacity_rejection_count +|= 1;54            failure = error.EventPayloadCapacityExceeded;55        }56        if (descriptor_count > self.descriptors.len) {57            self.descriptor_capacity_rejection_count +|= 1;58            if (failure == null) failure = error.EventDescriptorCapacityExceeded;59        }60        if (failure) |err| return err;61    }6263    pub fn storePayloadAssumeCapacity(64        self: *Storage,65        payload: []const u8,66    ) []const u8 {67        self.assertValid();68        std.debug.assert(self.payload_count == 0);69        std.debug.assert(self.descriptor_count == 0);70        std.debug.assert(payload.len <= self.payload.len);71        @memcpy(self.payload[0..payload.len], payload);72        self.payload_count = payload.len;73        self.assertValid();74        return self.payload[0..self.payload_count];75    }7677    pub fn storeRoutedAssumeCapacity(78        self: *Storage,79        payload: []const u8,80        owned_descriptors: []const sys.fd.Descriptor,81    ) StoredRouted {82        const stored_payload = self.storePayloadAssumeCapacity(payload);83        std.debug.assert(owned_descriptors.len <= self.descriptors.len);84        @memcpy(self.descriptors[0..owned_descriptors.len], owned_descriptors);85        self.descriptor_count = owned_descriptors.len;86        self.assertValid();87        return .{88            .payload = stored_payload,89            .descriptors = self.descriptors[0..self.descriptor_count],90        };91    }9293    pub fn status(self: *const Storage) Status {94        self.assertValid();95        return .{96            .event_payload_capacity_rejection_count = self.payload_capacity_rejection_count,97            .event_descriptor_capacity_rejection_count = self.descriptor_capacity_rejection_count,98        };99    }100101    fn assertValid(self: *const Storage) void {102        std.debug.assert(self.payload_count <= self.payload.len);103        std.debug.assert(self.descriptor_count <= self.descriptors.len);104    }105};

1pub const StorageError = error{2    EventPayloadCapacityExceeded,3    EventDescriptorCapacityExceeded,4};

1pub const Capacity = struct {2    retained_global_count: usize,3    interface_name_byte_count_per_global: usize,4    retained_global_bytes: usize,5    interface_name_bytes: usize,6    total_requested_bytes: usize,78    pub fn derive(limits: Limits) CapacityError!Capacity {9        const retained_global_bytes = std.math.mul(10            usize,11            limits.retained_global_count,12            @sizeOf(Slot),13        ) catch return error.CapacityOverflow;14        const interface_name_bytes = std.math.mul(15            usize,16            limits.retained_global_count,17            limits.interface_name_byte_count_per_global,18        ) catch return error.CapacityOverflow;19        const total_requested_bytes = std.math.add(20            usize,21            retained_global_bytes,22            interface_name_bytes,23        ) catch return error.CapacityOverflow;24        return .{25            .retained_global_count = limits.retained_global_count,26            .interface_name_byte_count_per_global = limits.interface_name_byte_count_per_global,27            .retained_global_bytes = retained_global_bytes,28            .interface_name_bytes = interface_name_bytes,29            .total_requested_bytes = total_requested_bytes,30        };31    }32};

1pub const CapacityError = error{CapacityOverflow};

1pub const Limits = struct {2    retained_global_count: usize = default_retained_global_count,3    interface_name_byte_count_per_global: usize =4        default_interface_name_byte_count_per_global,5};

1pub const Set = struct {2    session_allocator: std.mem.Allocator,3    slots: []Slot,4    interface_names: []u8,5    interface_name_byte_count_per_global: usize,6    count: usize = 0,7    capacity_rejection_count: u64 = 0,8    interface_name_capacity_rejection_count: u64 = 0,910    pub fn init(11        session_allocator: std.mem.Allocator,12        capacity: Capacity,13    ) std.mem.Allocator.Error!Set {14        const slots = try session_allocator.alloc(Slot, capacity.retained_global_count);15        errdefer if (slots.len != 0) session_allocator.free(slots);16        @memset(slots, null);17        return .{18            .session_allocator = session_allocator,19            .slots = slots,20            .interface_names = try session_allocator.alloc(21                u8,22                capacity.interface_name_bytes,23            ),24            .interface_name_byte_count_per_global = capacity.interface_name_byte_count_per_global,25        };26    }2728    pub fn deinit(self: *Set) void {29        self.assertValid();30        if (self.interface_names.len != 0) self.session_allocator.free(self.interface_names);31        if (self.slots.len != 0) self.session_allocator.free(self.slots);32        self.* = undefined;33    }3435    pub fn prepareAdd(36        self: *Set,37        registry_id: u32,38        name: u32,39        interface: []const u8,40        version: u32,41    ) Error!Admission {42        self.assertValid();43        if (version == 0) return error.InvalidVersion;44        var available_slot: ?usize = null;45        for (self.slots, 0..) |slot, slot_index| {46            const entry = slot orelse {47                if (available_slot == null) available_slot = slot_index;48                continue;49            };50            if (entry.registry_id == registry_id and entry.name == name) {51                return error.DuplicateGlobal;52            }53        }54        if (interface.len > self.interface_name_byte_count_per_global) {55            self.interface_name_capacity_rejection_count +|= 1;56            return error.GlobalInterfaceNameCapacityExceeded;57        }58        const slot_index = available_slot orelse {59            self.capacity_rejection_count +|= 1;60            return error.GlobalCapacityExceeded;61        };62        return .{63            .slot_index = slot_index,64            .registry_id = registry_id,65            .name = name,66            .interface_len = interface.len,67            .version = version,68        };69    }7071    pub fn commitAdd(72        self: *Set,73        admission: Admission,74        interface: []const u8,75    ) Global {76        self.assertValid();77        std.debug.assert(admission.slot_index < self.slots.len);78        std.debug.assert(self.slots[admission.slot_index] == null);79        std.debug.assert(interface.len == admission.interface_len);80        std.debug.assert(interface.len <= self.interface_name_byte_count_per_global);81        std.debug.assert(admission.version != 0);82        const storage = self.interfaceStorage(admission.slot_index);83        @memcpy(storage[0..interface.len], interface);84        self.slots[admission.slot_index] = .{85            .registry_id = admission.registry_id,86            .name = admission.name,87            .interface_len = interface.len,88            .version = admission.version,89        };90        self.count += 1;91        self.assertValid();92        return self.globalAt(admission.slot_index);93    }9495    pub fn add(96        self: *Set,97        registry_id: u32,98        name: u32,99        interface: []const u8,100        version: u32,101    ) Error!Global {102        return self.commitAdd(103            try self.prepareAdd(registry_id, name, interface, version),104            interface,105        );106    }107108    pub fn get(self: *const Set, registry_id: u32, name: u32) ?Global {109        self.assertValid();110        for (self.slots, 0..) |slot, slot_index| {111            const entry = slot orelse continue;112            if (entry.registry_id == registry_id and entry.name == name) {113                return self.globalAt(slot_index);114            }115        }116        return null;117    }118119    pub fn require(self: *const Set, registry_id: u32, name: u32) ModelError!Global {120        return self.get(registry_id, name) orelse error.UnknownGlobal;121    }122123    pub fn remove(self: *Set, registry_id: u32, name: u32) ModelError!void {124        self.assertValid();125        for (self.slots) |*slot| {126            const entry = slot.* orelse continue;127            if (entry.registry_id != registry_id or entry.name != name) continue;128            slot.* = null;129            std.debug.assert(self.count != 0);130            self.count -= 1;131            self.assertValid();132            return;133        }134        return error.UnknownGlobal;135    }136137    pub fn status(self: *const Set) Status {138        self.assertValid();139        const name_rejections = self.interface_name_capacity_rejection_count;140        return .{141            .global_capacity_rejection_count = self.capacity_rejection_count,142            .global_interface_name_capacity_rejection_count = name_rejections,143        };144    }145146    fn globalAt(self: *const Set, slot_index: usize) Global {147        const entry = self.slots[slot_index].?;148        const storage = self.interfaceStorage(slot_index);149        return .{150            .registry_id = entry.registry_id,151            .name = entry.name,152            .interface = storage[0..entry.interface_len],153            .version = entry.version,154        };155    }156157    fn interfaceStorage(self: *const Set, slot_index: usize) []u8 {158        const offset = slot_index * self.interface_name_byte_count_per_global;159        const end = offset + self.interface_name_byte_count_per_global;160        std.debug.assert(end <= self.interface_names.len);161        return self.interface_names[offset..end];162    }163164    fn assertValid(self: *const Set) void {165        std.debug.assert(self.count <= self.slots.len);166        std.debug.assert(167            self.interface_names.len ==168                self.slots.len * self.interface_name_byte_count_per_global,169        );170        var count: usize = 0;171        for (self.slots, 0..) |slot, slot_index| {172            const entry = slot orelse continue;173            count += 1;174            std.debug.assert(entry.interface_len <= self.interface_name_byte_count_per_global);175            for (self.slots[slot_index + 1 ..]) |other_slot| {176                const other = other_slot orelse continue;177                if (entry.registry_id == other.registry_id) {178                    std.debug.assert(entry.name != other.name);179                }180            }181        }182        std.debug.assert(count == self.count);183    }184};

1pub const Status = struct {2    global_capacity_rejection_count: u64 = 0,3    global_interface_name_capacity_rejection_count: u64 = 0,4};

1pub const StorageError = error{2    GlobalCapacityExceeded,3    GlobalInterfaceNameCapacityExceeded,4};

1pub const RoutedView = struct {2    object_id: u32,3    interface: *const wayland.protocol.schema.Interface,4    version: u32,5    metadata: *const wayland.protocol.schema.Message,6    payload: []const u8,7    descriptors: []sys.fd.Descriptor,89    pub fn borrowedDecoder(10        self: *const RoutedView,11    ) wayland.protocol.value.DecodeError!wayland.protocol.value.Decoder {12        return .init(self.metadata, self.payload, self.descriptors);13    }1415    pub fn takeDescriptor(16        self: *RoutedView,17        index: usize,18    ) error{ InvalidIndex, DescriptorAlreadyTaken }!sys.fd.Descriptor {19        if (index >= self.descriptors.len) return error.InvalidIndex;20        const descriptor = self.descriptors[index];21        if (descriptor < 0) return error.DescriptorAlreadyTaken;22        self.descriptors[index] = -1;23        return descriptor;24    }25};

1pub const Capacity = struct {2    client_object_count: usize,3    server_object_count: usize,4    client_slot_bytes: usize,5    server_slot_bytes: usize,6    total_requested_bytes: usize,78    pub fn derive(limits: Limits) CapacityError!Capacity {9        if (limits.client_object_count > maximum_client_object_count) {10            return error.ClientObjectStorageTooLarge;11        }12        if (limits.server_object_count > maximum_server_object_count) {13            return error.ServerObjectStorageTooLarge;14        }15        const client_slot_bytes = std.math.mul(16            usize,17            limits.client_object_count,18            @sizeOf(ClientSlot),19        ) catch return error.CapacityOverflow;20        const server_slot_bytes = std.math.mul(21            usize,22            limits.server_object_count,23            @sizeOf(ServerSlot),24        ) catch return error.CapacityOverflow;25        const total_requested_bytes = std.math.add(26            usize,27            client_slot_bytes,28            server_slot_bytes,29        ) catch return error.CapacityOverflow;30        return .{31            .client_object_count = limits.client_object_count,32            .server_object_count = limits.server_object_count,33            .client_slot_bytes = client_slot_bytes,34            .server_slot_bytes = server_slot_bytes,35            .total_requested_bytes = total_requested_bytes,36        };37    }38};

1pub const CapacityError = error{2    ClientObjectStorageTooLarge,3    ServerObjectStorageTooLarge,4    CapacityOverflow,5};

1pub const Entry = struct {2    interface: *const wayland.protocol.schema.Interface,3    version: u32,4    origin: Origin,5    state: State = .live,6};

1pub const Limits = struct {2    client_object_count: usize = default_client_object_count,3    server_object_count: usize = default_server_object_count,4};

1pub const ServerSlot = struct {2    id: u32,3    entry: Entry,4};

1pub const Status = struct {2    client_object_capacity_rejection_count: u64 = 0,3    server_object_capacity_rejection_count: u64 = 0,4};

1pub const StorageError = error{2    ClientObjectCapacityExceeded,3    ServerObjectCapacityExceeded,4};

1pub const NewId = union(enum) {2    fixed,3    dynamic: Dynamic,45    pub const Dynamic = struct {6        interface: []const u8,7        version: u32,8    };9};

1pub const Value = union(enum) {2    int: i32,3    uint: u32,4    fixed: wayland.protocol.value.Fixed,5    string: ?[]const u8,6    object: ?u32,7    new_id: NewId,8    array: []const u8,9    descriptor_owned: sys.fd.Descriptor,10};

1pub const CapacityError = wayland.TransportCapacityError ||2    wayland.protocol.value.EncoderCapacityError ||3    event.CapacityError ||4    wayland.ids.CapacityError ||5    object_model.CapacityError ||6    global_state.CapacityError ||7    error{CapacityOverflow};

1pub const default_capacity = Capacity.derive(.{}) catch unreachable;

1pub const maximum_descriptor_count = maximumDescriptorCount(2    &wayland.protocol.interfaces,3);

1pub const Slot = ?Entry;

1pub const default_interface_name_byte_count_per_global: usize = 128;

1pub const default_retained_global_count: usize = 256;

1pub const ClientSlot = ?Entry;

1pub const default_server_object_count: usize = 256;

1pub const maximum_server_object_count: usize =2    @as(usize, std.math.maxInt(u32) - wayland.ids.first_server_id) + 1;

1pub const default_client_object_count: usize = wayland.ids.default_client_id_count;

1pub const maximum_client_object_count: usize = wayland.ids.maximum_client_id_count;

1pub const runtime = @import("runtime/root.zig");

1const client = @import("client.zig");2pub const creation = @import("creation.zig");3const event = @import("event.zig");4const global = @import("global.zig");5const message = @import("message.zig");6const object = @import("object.zig");7const request = @import("request.zig");89pub const Client = client.Client;10pub const Limits = client.Limits;11pub const Capacity = client.Capacity;12pub const CapacityError = client.CapacityError;13pub const StorageStatus = client.StorageStatus;14pub const default_client_object_count = client.default_client_object_count;15pub const default_server_object_count = client.default_server_object_count;16pub const default_retained_global_count = client.default_retained_global_count;17pub const default_global_interface_name_byte_count =18    client.default_global_interface_name_byte_count;19pub const maximum_client_object_count = object.maximum_client_object_count;20pub const maximum_server_object_count = object.maximum_server_object_count;21pub const ObjectLimits = object.Limits;22pub const ObjectCapacity = object.Capacity;23pub const ObjectCapacityError = object.CapacityError;24pub const ObjectStorageError = object.StorageError;25pub const ObjectStorageStatus = object.Status;26pub const ObjectClientSlot = object.ClientSlot;27pub const ObjectServerSlot = object.ServerSlot;28pub const GlobalLimits = global.Limits;29pub const GlobalCapacity = global.Capacity;30pub const GlobalCapacityError = global.CapacityError;31pub const GlobalStorageError = global.StorageError;32pub const GlobalStorageStatus = global.Status;33pub const GlobalStorageSlot = global.Slot;34pub const GlobalStorage = global.Set;35pub const EventCreationLimits = creation.Limits;36pub const EventCreationCapacity = creation.Capacity;37pub const EventCreationCapacityError = creation.CapacityError;38pub const EventCreationStorageError = creation.StorageError;39pub const EventCreationStatus = creation.Status;40pub const maximum_event_creation_count = creation.maximum_event_creation_count;41pub const EventStorageLimits = event.Limits;42pub const EventStorageCapacity = event.Capacity;43pub const EventStorageCapacityError = event.CapacityError;44pub const EventStorageError = event.StorageError;45pub const EventStorageStatus = event.Status;46pub const EventStorage = event.Storage;47pub const default_event_storage_capacity = event.default_capacity;48pub const maximum_event_descriptor_count = event.maximum_descriptor_count;49pub const EventView = event.EventView;50pub const GlobalView = event.GlobalView;51pub const NewId = request.NewId;52pub const Object = object.Entry;53pub const RoutedView = message.RoutedView;54pub const Step = event.Step;55pub const Value = request.Value;