Simplify the public API into one dense header

yasl.h now holds everything except Vulkan: 45 functions instead of 62,
and three installed headers instead of ten.

- One constructor: yasl_surface_create takes CPU, GL or NATIVE, with
  zero-initialized GL options meaning 3.2 core, RGBA8, D24S8.
- Events carry action, mods, x, y and text at the top level; pen
  positions are now logical like pointer positions.
- yasl_cpu_pixels/yasl_cpu_present draw into one persistent canvas,
  cutting three full-frame copies per frame.
- yasl_surface_get_info, yasl_surface_request, YASL_CURSOR_LOCKED,
  yasl_surface_set_text_input, yasl_surface_begin_move_resize and
  yasl_surface_get_native replace groups of narrower calls.
- Interactive calls drop the decorative trigger event argument.
- yasl_wait_event returns 0 only on timeout or yasl_wake, the refresh
  callback runs only in native modal loops, focus loss sends
  INPUT_RESET, and a lost event no longer fails every later wait.
- Unsupported operations and bad arguments report ENOTSUP and EINVAL
  instead of EIO; the keycodes header no longer needs C23.
- The shared library gets a versioned SONAME and version macros.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

1 files changed, 50 insertions, 70 deletions

diff --git a/src/common/vulkan.c b/src/common/vulkan.c
index 77a4dd4..cdf3e8b 100644
--- a/src/common/vulkan.c
+++ b/src/common/vulkan.c
@@ -12,12 +12,6 @@
 #include <errno.h>
 #include <stdlib.h>
 #include <string.h>
-#if YASL_HAS_WAYLAND
-#include "yasl/native/wayland.h"
-#endif
-#if YASL_HAS_X11
-#include "yasl/native/x11.h"
-#endif
 static PFN_vkGetInstanceProcAddr get_proc;
 static bool portability;
 void yasl_private_vulkan_reset(void)
@@ -32,17 +26,40 @@ struct yasl_vulkan_binding {
     bool has_allocator;
     PFN_vkDestroySurfaceKHR destroy;
 };
-int yasl_vulkan_init(PFN_vkGetInstanceProcAddr loader)
+static bool backend_requirements(struct yasl_vulkan_requirements *out)
 {
-    struct yasl_private_display *d = yasl_public_display();
-    if (d && !yasl_public_owner())
-        return -errno;
+    static const char *const wayland[] = {"VK_KHR_surface", "VK_KHR_wayland_surface"};
+    static const char *const x11[] = {"VK_KHR_surface", "VK_KHR_xlib_surface"};
+    static const char *const metal[] = {"VK_KHR_surface", "VK_EXT_metal_surface",
+                                        "VK_KHR_portability_enumeration"};
+    switch (yasl_public_display()->ops->type) {
+    case YASL_PRIVATE_BACKEND_WAYLAND:
+        *out = (struct yasl_vulkan_requirements){wayland, 2, 0};
+        return true;
+    case YASL_PRIVATE_BACKEND_X11:
+        *out = (struct yasl_vulkan_requirements){x11, 2, 0};
+        return true;
+    case YASL_PRIVATE_BACKEND_COCOA:
+        *out = (struct yasl_vulkan_requirements){
+            metal, portability ? 3 : 2,
+            portability ? VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR : 0};
+        return true;
+    default:
+        return yasl_public_fail(ENOTSUP);
+    }
+}
+int yasl_vulkan_init(PFN_vkGetInstanceProcAddr loader, struct yasl_vulkan_requirements *out)
+{
+    if (!out)
+        return yasl_public_error(EINVAL);
+    *out = (struct yasl_vulkan_requirements){0};
     if (!loader)
         return yasl_public_error(EINVAL);
-    if (d)
-        for (yasl_surface *s = d->surfaces; s; s = s->event_next)
-            if (s->vulkan)
-                return yasl_public_error(EBUSY);
+    if (!yasl_public_initialize())
+        return -errno;
+    for (yasl_surface *s = yasl_public_display()->surfaces; s; s = s->event_next)
+        if (s->vulkan)
+            return yasl_public_error(EBUSY);
     PFN_vkEnumerateInstanceExtensionProperties enumerate =
         (PFN_vkEnumerateInstanceExtensionProperties)loader(
             VK_NULL_HANDLE, "vkEnumerateInstanceExtensionProperties");
@@ -50,59 +67,22 @@ int yasl_vulkan_init(PFN_vkGetInstanceProcAddr loader)
         return yasl_public_error(ENOTSUP);
     uint32_t count = 0;
     VkResult result = enumerate(NULL, &count, NULL);
-    if (result != VK_SUCCESS)
-        return yasl_public_error(EIO);
-    VkExtensionProperties *ext = count ? calloc(count, sizeof(*ext)) : NULL;
-    if (count && !ext)
-        return yasl_public_error(ENOMEM);
-    bool next_portability = false;
-    if (count)
+    VkExtensionProperties *ext = NULL;
+    if (result == VK_SUCCESS && count) {
+        if (!(ext = calloc(count, sizeof(*ext))))
+            return yasl_public_error(ENOMEM);
         result = enumerate(NULL, &count, ext);
-    if (result == VK_SUCCESS)
-        for (uint32_t i = 0; i < count; i++)
-            if (!strcmp(ext[i].extensionName, "VK_KHR_portability_enumeration"))
-                next_portability = true;
+    }
+    bool next_portability = false;
+    for (uint32_t i = 0; result == VK_SUCCESS && i < count; i++)
+        if (!strcmp(ext[i].extensionName, "VK_KHR_portability_enumeration"))
+            next_portability = true;
     free(ext);
     if (result != VK_SUCCESS)
         return yasl_public_error(EIO);
     get_proc = loader;
     portability = next_portability;
-    return 0;
-}
-int yasl_vulkan_get_requirements(const yasl_surface *s, struct yasl_vulkan_requirements *out)
-{
-    static const char *const wayland[] = {"VK_KHR_surface", "VK_KHR_wayland_surface"};
-    static const char *const x11[] = {"VK_KHR_surface", "VK_KHR_xlib_surface"};
-    static const char *const metal[] = {"VK_KHR_surface", "VK_EXT_metal_surface",
-                                        "VK_KHR_portability_enumeration"};
-    if (!out)
-        return yasl_public_error(EINVAL);
-    *out = (struct yasl_vulkan_requirements){0};
-    if (!yasl_public_surface((yasl_surface *)s, false))
-        return -errno;
-    if (!get_proc)
-        return yasl_public_error(ENODEV);
-    if (s->presenter != YASL_PRIVATE_PRESENTER_NONE &&
-        s->presenter != YASL_PRIVATE_PRESENTER_VULKAN)
-        return yasl_public_error(EBUSY);
-    switch (s->display->ops->type) {
-    case YASL_PRIVATE_BACKEND_WAYLAND:
-        out->extensions = wayland;
-        out->extension_count = 2;
-        break;
-    case YASL_PRIVATE_BACKEND_X11:
-        out->extensions = x11;
-        out->extension_count = 2;
-        break;
-    case YASL_PRIVATE_BACKEND_COCOA:
-        out->extensions = metal;
-        out->extension_count = portability ? 3 : 2;
-        out->flags = portability ? VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR : 0;
-        break;
-    default:
-        return yasl_public_error(ENOTSUP);
-    }
-    return 0;
+    return backend_requirements(out) ? 0 : -errno;
 }
 int yasl_vulkan_destroy_surface(yasl_surface *s)
 {
@@ -133,7 +113,7 @@ VkResult yasl_vulkan_create_surface(yasl_surface *s, VkInstance instance,
         yasl_public_fail(ENODEV);
         return VK_ERROR_INITIALIZATION_FAILED;
     }
-    if (s->display->offline) {
+    if (atomic_load(&s->display->offline)) {
         yasl_public_fail(ENOTCONN);
         return VK_ERROR_SURFACE_LOST_KHR;
     }
@@ -156,16 +136,16 @@ VkResult yasl_vulkan_create_surface(yasl_surface *s, VkInstance instance,
     switch (s->display->ops->type) {
 #if YASL_HAS_WAYLAND
     case YASL_PRIVATE_BACKEND_WAYLAND: {
-        struct yasl_wayland_handles native;
-        if (yasl_wayland_get_native(s, &native) < 0)
+        struct yasl_native native;
+        if (yasl_surface_get_native(s, &native) < 0)
             break;
         PFN_vkCreateWaylandSurfaceKHR create =
             (PFN_vkCreateWaylandSurfaceKHR)get_proc(instance, "vkCreateWaylandSurfaceKHR");
         if (create) {
             VkWaylandSurfaceCreateInfoKHR info = {
                 .sType = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR,
-                .display = native.display,
-                .surface = native.surface};
+                .display = native.wl_display,
+                .surface = native.wl_surface};
             result = create(instance, &info, allocator, out);
         }
         break;
@@ -173,16 +153,16 @@ VkResult yasl_vulkan_create_surface(yasl_surface *s, VkInstance instance,
 #endif
 #if YASL_HAS_X11
     case YASL_PRIVATE_BACKEND_X11: {
-        struct yasl_x11_handles native;
-        if (yasl_x11_get_native(s, &native) < 0)
+        struct yasl_native native;
+        if (yasl_surface_get_native(s, &native) < 0)
             break;
         PFN_vkCreateXlibSurfaceKHR create =
             (PFN_vkCreateXlibSurfaceKHR)get_proc(instance, "vkCreateXlibSurfaceKHR");
         if (create) {
             VkXlibSurfaceCreateInfoKHR info = {.sType =
                                                    VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR,
-                                               .dpy = native.display,
-                                               .window = (Window)native.window};
+                                               .dpy = native.x11_display,
+                                               .window = (Window)native.x11_window};
             result = create(instance, &info, allocator, out);
         }
         break;