Simplify the public event and CPU API

Applications now need far less ceremony: hello.c is a 20-line loop that
handles REFRESH, CLOSE and QUIT and draws into the surface's own pixels.

- Fold GEOMETRY, STATE and FOCUS into one WINDOW event carrying size,
  scale and state; unchanged values send nothing.
- Guarantee REFRESH once a window has a size and after every resize,
  never at size zero.
- Merge DROP_HOVER into DROP with over/leave/data actions and give drag
  and drop actions enums.
- Keep event strings valid until the next wait and drop
  yasl_event_release; empty or failed waits report NONE.
- Replace copy-in presentation with a lent pixel buffer:
  yasl_cpu_pixels and yasl_cpu_present.
- Remove yasl_poll_event, yasl_cpu_read_pixels, unused event fields and
  comments that restated names.
- Wayland: resize floating windows in request_size instead of reporting
  it unsupported, and stop marking new GPU surfaces as Vulkan so
  yasl_vulkan_create_surface no longer fails with NATIVE_WINDOW_IN_USE.

Also includes the in-progress public API refactor that was uncommitted
in the tree (removal of the app/loop layer, new surface, GL and Vulkan
entry points).

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

1 files changed, 38 insertions, 38 deletions

diff --git a/tests/common/test_loop.c b/tests/common/test_loop.c
index f982e5e..5c49691 100644
--- a/tests/common/test_loop.c
+++ b/tests/common/test_loop.c
@@ -1,6 +1,6 @@
 #define _GNU_SOURCE
 #define _DARWIN_C_SOURCE
-#include "yasl/loop.h"
+#include "common/private_loop.h"
 
 #include <assert.h>
 #include <errno.h>
@@ -29,7 +29,7 @@ static void on_alarm(int signo)
 }
 
 struct post_log {
-    struct yasl_loop *loop;
+    struct yasl_private_loop *loop;
     char order[8];
     int count;
 };
@@ -46,7 +46,7 @@ static void post_a(void *ud)
 {
     struct post_log *log = ud;
     log->order[log->count++] = 'a';
-    assert(yasl_loop_post(log->loop, post_c, log));
+    assert(yasl_private_loop_post(log->loop, post_c, log));
 }
 
 static void post_b(void *ud)
@@ -57,28 +57,28 @@ static void post_b(void *ud)
 
 static void test_post_order(void)
 {
-    struct yasl_loop *l = yasl_loop_create();
+    struct yasl_private_loop *l = yasl_private_loop_create();
     assert(l);
-    assert(!yasl_loop_post(NULL, post_b, NULL));
-    assert(!yasl_loop_post(l, NULL, NULL));
+    assert(!yasl_private_loop_post(NULL, post_b, NULL));
+    assert(!yasl_private_loop_post(l, NULL, NULL));
 
     struct post_log log = {.loop = l};
-    assert(yasl_loop_post(l, post_a, &log));
-    assert(yasl_loop_post(l, post_b, &log));
-    assert(yasl_loop_step(l, 0) >= 1);
+    assert(yasl_private_loop_post(l, post_a, &log));
+    assert(yasl_private_loop_post(l, post_b, &log));
+    assert(yasl_private_loop_step(l, 0) >= 1);
     /* A post made while posts run waits for a later step. */
     assert(log.count == 2 && memcmp(log.order, "ab", 2) == 0);
-    assert(yasl_loop_step(l, 0) >= 1);
+    assert(yasl_private_loop_step(l, 0) >= 1);
     assert(log.count == 3 && log.order[2] == 'c');
 
     /* Destroy drops posts that never ran. */
-    assert(yasl_loop_post(l, post_b, &log));
-    yasl_loop_destroy(l);
+    assert(yasl_private_loop_post(l, post_b, &log));
+    yasl_private_loop_destroy(l);
     assert(log.count == 3);
 }
 
 struct thread_ctx {
-    struct yasl_loop *loop;
+    struct yasl_private_loop *loop;
     bool kick;
     int signo;
     _Atomic bool ran;
@@ -97,35 +97,35 @@ static void *wake_thread(void *ud)
     if (ctx->signo)
         kill(getpid(), ctx->signo);
     else if (ctx->kick)
-        yasl_loop_kick(ctx->loop);
+        yasl_private_loop_kick(ctx->loop);
     else
-        assert(yasl_loop_post(ctx->loop, mark_ran, ctx));
+        assert(yasl_private_loop_post(ctx->loop, mark_ran, ctx));
     return NULL;
 }
 
 static void test_cross_thread(void)
 {
-    struct yasl_loop *l = yasl_loop_create();
+    struct yasl_private_loop *l = yasl_private_loop_create();
     assert(l);
 
     struct thread_ctx post = {.loop = l};
     pthread_t t;
     assert(pthread_create(&t, NULL, wake_thread, &post) == 0);
     while (!post.ran)
-        assert(yasl_loop_step(l, -1) >= 0);
+        assert(yasl_private_loop_step(l, -1) >= 0);
     pthread_join(t, NULL);
 
     /* A kick ends an indefinite wait without running anything. */
     struct thread_ctx kick = {.loop = l, .kick = true};
     assert(pthread_create(&t, NULL, wake_thread, &kick) == 0);
-    assert(yasl_loop_step(l, -1) >= 1);
+    assert(yasl_private_loop_step(l, -1) >= 1);
     pthread_join(t, NULL);
 
-    yasl_loop_destroy(l);
+    yasl_private_loop_destroy(l);
 }
 
 struct signal_log {
-    struct yasl_loop *loop;
+    struct yasl_private_loop *loop;
     int seen[NSIG];
     int total;
     bool unwatch;
@@ -138,7 +138,7 @@ static void on_signal(void *ud, int signo)
     log->seen[signo]++;
     log->total++;
     if (log->unwatch)
-        yasl_loop_unwatch_signals(log->loop);
+        yasl_private_loop_unwatch_signals(log->loop);
 }
 
 static volatile sig_atomic_t previous_handler_hits;
@@ -149,10 +149,10 @@ static void previous_handler(int signo)
     previous_handler_hits++;
 }
 
-static void step_until(struct yasl_loop *l, const int *counter, int want)
+static void step_until(struct yasl_private_loop *l, const int *counter, int want)
 {
     while (*counter < want)
-        assert(yasl_loop_step(l, -1) >= 0);
+        assert(yasl_private_loop_step(l, -1) >= 0);
 }
 
 static void test_signals(void)
@@ -161,30 +161,30 @@ static void test_signals(void)
     sigemptyset(&prev.sa_mask);
     assert(sigaction(SIGUSR2, &prev, NULL) == 0);
 
-    struct yasl_loop *l = yasl_loop_create();
-    struct yasl_loop *other = yasl_loop_create();
+    struct yasl_private_loop *l = yasl_private_loop_create();
+    struct yasl_private_loop *other = yasl_private_loop_create();
     assert(l && other);
     struct signal_log log = {.loop = l};
 
     const int bad[] = {SIGKILL};
     errno = 0;
-    assert(!yasl_loop_watch_signals(l, bad, 1, on_signal, &log) && errno == EINVAL);
+    assert(!yasl_private_loop_watch_signals(l, bad, 1, on_signal, &log) && errno == EINVAL);
     const int sigs[] = {SIGUSR1, SIGUSR2, SIGCHLD};
     errno = 0;
-    assert(!yasl_loop_watch_signals(l, sigs, 0, on_signal, &log) && errno == EINVAL);
+    assert(!yasl_private_loop_watch_signals(l, sigs, 0, on_signal, &log) && errno == EINVAL);
     errno = 0;
-    assert(!yasl_loop_watch_signals(l, sigs, 3, NULL, &log) && errno == EINVAL);
-    assert(yasl_loop_watch_signals(l, sigs, 3, on_signal, &log));
+    assert(!yasl_private_loop_watch_signals(l, sigs, 3, NULL, &log) && errno == EINVAL);
+    assert(yasl_private_loop_watch_signals(l, sigs, 3, on_signal, &log));
 
     /* One signal belongs to one loop at a time. */
     errno = 0;
-    assert(!yasl_loop_watch_signals(other, sigs, 1, on_signal, &log) && errno == EBUSY);
+    assert(!yasl_private_loop_watch_signals(other, sigs, 1, on_signal, &log) && errno == EBUSY);
 
     /* Deliveries before the callback runs coalesce per signal. */
     raise(SIGUSR1);
     raise(SIGUSR1);
     raise(SIGUSR2);
-    assert(yasl_loop_step(l, 0) >= 1);
+    assert(yasl_private_loop_step(l, 0) >= 1);
     assert(log.seen[SIGUSR1] == 1 && log.seen[SIGUSR2] == 1);
     assert(previous_handler_hits == 0);
 
@@ -205,11 +205,11 @@ static void test_signals(void)
 
     /* Replacing the watch restores the signals it drops. */
     const int only_usr1[] = {SIGUSR1};
-    assert(yasl_loop_watch_signals(l, only_usr1, 1, on_signal, &log));
+    assert(yasl_private_loop_watch_signals(l, only_usr1, 1, on_signal, &log));
     raise(SIGUSR2);
     assert(previous_handler_hits == 1);
-    assert(yasl_loop_watch_signals(other, (const int[]){SIGUSR2}, 1, on_signal, &log));
-    yasl_loop_unwatch_signals(other);
+    assert(yasl_private_loop_watch_signals(other, (const int[]){SIGUSR2}, 1, on_signal, &log));
+    yasl_private_loop_unwatch_signals(other);
     assert(previous_handler_hits == 1);
     raise(SIGUSR2);
     assert(previous_handler_hits == 2);
@@ -221,15 +221,15 @@ static void test_signals(void)
     struct sigaction now;
     assert(sigaction(SIGUSR1, NULL, &now) == 0);
     assert(now.sa_handler == SIG_DFL);
-    yasl_loop_unwatch_signals(l);
+    yasl_private_loop_unwatch_signals(l);
 
     /* Destroy unwatches. */
     log.unwatch = false;
-    assert(yasl_loop_watch_signals(l, only_usr1, 1, on_signal, &log));
-    yasl_loop_destroy(l);
+    assert(yasl_private_loop_watch_signals(l, only_usr1, 1, on_signal, &log));
+    yasl_private_loop_destroy(l);
     assert(sigaction(SIGUSR1, NULL, &now) == 0);
     assert(now.sa_handler == SIG_DFL);
-    yasl_loop_destroy(other);
+    yasl_private_loop_destroy(other);
 
     struct sigaction dfl = {.sa_handler = SIG_DFL};
     sigemptyset(&dfl.sa_mask);