@lucent-lang/lucent 0.1.2 → 0.1.3

package/lib/sdk/android.d.ts

@@ -1,10 +1,22 @@
 // lucent:android — Android helpers for platform code.
 import type { Activity, Instrumentation_ActivityResult } from "lucent:android/android.app";
 import type { Context, Intent } from "lucent:android/android.content";
+import type { Throwable } from "lucent:android/java.lang";
 
 /** The application Context. */
 export declare function appContext(): Context;
 
+/**
+ * The Error Lucent makes of `throwable` when a call throws it: its message
+ * the exception's (or its class name, without one) and its `code` the class
+ * name (`java.lang.IllegalStateException`). An exception carrying a Lucent
+ * error (one a Lucent suspend function ended a Kotlin call with) gives
+ * that error.
+ * For an adapter whose callback API reports failure with a Throwable:
+ * `reject(errorOf(e))` rejects as the call would have thrown.
+ */
+export declare function errorOf(throwable: Throwable): Error;
+
 /** Whether the device runs at least API level `api` (`Build.VERSION.SDK_INT >= api`). */
 export declare function available(platform: "android", api: number): boolean;
 

package/lib/sdk/compose.d.ts

@@ -32,8 +32,8 @@
  *
  * @experimental
  */
-import type { ViewGroup } from "lucent:android/android.view";
-import type { Bound } from "lucent:ui";
+import type { View, ViewGroup } from "lucent:android/android.view";
+import type { Bound, NativeViewTag } from "lucent:ui";
 
 /** Kotlin's Float: a number, converted where the body passes it. */
 export type Float = number & { readonly "lucent:compose.Float"?: never };
@@ -76,15 +76,28 @@ export type ScopedChildren<S> = Shown | ((scope: S) => Shown);
 
 /**
  * How TypeScript types an Android file's JSX: an element is a composable,
- * a function of its props whose children are its `children` prop.
+ * a function of its props whose children are its `children` prop, or a
+ * view class (T48), typed with its declarations' `~jsx` attributes, as
+ * native-jsx-dts.ts writes the generated toolkits' namespaces.
  */
 export declare namespace JSX {
-  type Element = Composed;
+  type Element = Composed & View;
+
+  type ElementType = ((props: never) => Composed) | NativeViewTag<View>;
 
   interface ElementChildrenAttribute {
     children: {};
   }
 
+  interface ElementAttributesProperty {
+    "~jsx": {};
+  }
+
+  interface IntrinsicClassAttributes<T> {
+    /** Makes the view, where its class has no frame or Context constructor to make it with. */
+    create?: () => T;
+  }
+
   interface IntrinsicElements {}
 }
 

package/lib/sdk/ui.d.ts

@@ -97,6 +97,27 @@ export interface Children {
  */
 export declare function slot<T extends object>(): T;
 
+/** A native view class, as a JSX tag: any class whose instances are `V`. */
+export type NativeViewTag<V> = abstract new (...args: never[]) => V;
+
+/**
+ * The JSX attributes of a native view class: what each class in its
+ * hierarchy gives under its own `~jsx:<module>.<class>` key (derived by
+ * rule from its declarations), together. Each key's type takes the class
+ * itself (`this`), so a control event's handler gets the tag's class.
+ */
+export type NativeAttributes<T> = [
+  {
+    [K in keyof T]-?: K extends `~jsx:${string}` ? (x: NonNullable<T[K]>) => void : never;
+  }[keyof T],
+] extends [never]
+  ? {}
+  : {
+        [K in keyof T]-?: K extends `~jsx:${string}` ? (x: NonNullable<T[K]>) => void : never;
+      }[keyof T] extends (x: infer I) => void
+    ? I
+    : never;
+
 /**
  * Has the view measured again, once the main thread's current work ends:
  * for a change to its native content its host would not hear of. The host

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lucent-lang/lucent",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Write native React Native modules in TypeScript: the Lucent compiler, CLI, Metro integration, Expo config plugin and editor plugin",
   "homepage": "https://lucent-lang.dev",
   "bugs": "https://github.com/Fausto95/lucent/issues",
@@ -53,10 +53,10 @@
     "@types/react": "^19.2.0",
     "ajv": "^8",
     "ink-testing-library": "^4.0.0",
-    "@lucent-lang/codegen": "0.0.3",
     "@lucent-lang/bindgen": "0.0.3",
-    "@lucent-lang/compiler": "0.0.3",
-    "@lucent-lang/runtime": "0.0.3"
+    "@lucent-lang/codegen": "0.0.3",
+    "@lucent-lang/runtime": "0.0.3",
+    "@lucent-lang/compiler": "0.0.3"
   },
   "scripts": {}
 }

package/runtime/cpp/lucent/platform/android.cpp

@@ -1,12 +1,16 @@
 // Lucent runtime — Android: JNI environment, classes, errors, the main
-// Looper. Built only into Android apps (fbjni comes with React Native).
-#ifdef __ANDROID__
+// Looper. Built into Android apps (fbjni comes with React Native); its JNI
+// alone also into the desktop JNI host the tests run on a JVM
+// (LUCENT_JNI_HOST), which defines env(), appContext() and available().
+#if defined(__ANDROID__) || defined(LUCENT_JNI_HOST)
 
 #include "android.h"
 
+#ifdef __ANDROID__
 #include <fbjni/NativeRunnable.h>
 #include <fbjni/fbjni.h>
 #include <sys/system_properties.h>
+#endif
 
 #include <atomic>
 #include <cstdint>
@@ -19,7 +23,9 @@
 
 namespace lucent::jni {
 
+#ifdef __ANDROID__
 JNIEnv* env() { return facebook::jni::Environment::ensureCurrentThreadIsAttached(); }
+#endif
 
 namespace {
 
@@ -103,12 +109,14 @@ std::vector<Thrown>& thrown() {
   return *v;
 }
 
-/// The Lucent error `t` carries, removed from the list; none for other exceptions.
-std::optional<Error> takeThrown(JNIEnv* e, jobject t) {
+/// The Lucent error `t` carries, removed from the list when `take` (Lucent
+/// has caught the exception); none for other exceptions.
+std::optional<Error> findThrown(JNIEnv* e, jobject t, bool take) {
   std::lock_guard<std::mutex> g(thrownMutex);
   auto& v = thrown();
   for (auto it = v.begin(); it != v.end(); ++it) {
     if (!e->IsSameObject(it->exception, t)) continue;
+    if (!take) return it->error;
 
     Error error = std::move(it->error);
     e->DeleteWeakGlobalRef(it->exception);
@@ -120,13 +128,13 @@ std::optional<Error> takeThrown(JNIEnv* e, jobject t) {
 
 }  // namespace
 
-void throwToJava(JNIEnv* e, Error error) {
+jthrowable throwableOf(JNIEnv* e, Error error) {
   static jclass cls = findClass("java/lang/RuntimeException");
   static jmethodID init = method(cls, "<init>", "(Ljava/lang/String;)V");
   jstring message = toJString(e, error->message);
   auto exception = static_cast<jthrowable>(e->NewObject(cls, init, message));
   e->DeleteLocalRef(message);
-  if (!exception) return;  // A pending OutOfMemoryError ends the call instead.
+  if (!exception) return nullptr;  // A pending OutOfMemoryError ends the call instead.
 
   {
     std::lock_guard<std::mutex> g(thrownMutex);
@@ -139,37 +147,159 @@ void throwToJava(JNIEnv* e, Error error) {
     });
     v.push_back({e->NewWeakGlobalRef(exception), std::move(error)});
   }
+  return exception;
+}
+
+void throwToJava(JNIEnv* e, Error error) {
+  jthrowable exception = throwableOf(e, std::move(error));
+  if (!exception) return;
+
   e->Throw(exception);
   e->DeleteLocalRef(exception);
 }
 
+namespace {
+
+/// A primitive of descriptor `d`, from its boxed object.
+jvalue unboxed(JNIEnv* e, char d, jobject boxed) {
+  jvalue v{};
+  switch (d) {
+    case 'Z': v.z = unboxBoolean(e, boxed) ? JNI_TRUE : JNI_FALSE; break;
+    case 'J': v.j = unboxLong(e, boxed); break;
+    case 'I': v.i = static_cast<jint>(unboxNumber(e, boxed)); break;
+    case 'S': v.s = static_cast<jshort>(unboxNumber(e, boxed)); break;
+    case 'B': v.b = static_cast<jbyte>(unboxNumber(e, boxed)); break;
+    case 'C': v.c = static_cast<jchar>(unboxNumber(e, boxed)); break;
+    case 'F': v.f = static_cast<jfloat>(unboxNumber(e, boxed)); break;
+    case 'D': v.d = unboxNumber(e, boxed); break;
+    default: v.l = boxed;
+  }
+  return v;
+}
+
+}  // namespace
+
+jobject boxValueClass(JNIEnv* e, const char* cls, const char* underlying, jobject value) {
+  if (!value && underlying[0] != 'L' && underlying[0] != '[') return nullptr;
+
+  jclass c = findClass(cls);
+  std::string sig = std::string("(") + underlying + ")L" + cls + ";";
+  jmethodID box = staticMethod(c, "box-impl", sig.c_str());
+  jvalue v = unboxed(e, underlying[0], value);
+  jobject r = e->CallStaticObjectMethodA(c, box, &v);
+  check(e);
+  return r;
+}
+
+jobject unboxValueClass(JNIEnv* e, const char* cls, const char* underlying, jobject boxed) {
+  if (!boxed) return nullptr;
+
+  jmethodID unbox = method(findClass(cls), "unbox-impl", (std::string("()") + underlying).c_str());
+
+  // Each read checked before the boxing calls Java again.
+  auto read = [e](auto v) {
+    check(e);
+    return v;
+  };
+  switch (underlying[0]) {
+    case 'Z': return boxBoolean(e, read(e->CallBooleanMethod(boxed, unbox)) == JNI_TRUE);
+    case 'J': return boxLong(e, read(e->CallLongMethod(boxed, unbox)));
+    case 'I': return boxInt(e, read(e->CallIntMethod(boxed, unbox)));
+    case 'S': return boxShort(e, read(e->CallShortMethod(boxed, unbox)));
+    case 'B': return boxByte(e, read(e->CallByteMethod(boxed, unbox)));
+    case 'C': return boxChar(e, read(e->CallCharMethod(boxed, unbox)));
+    case 'F': return boxFloat(e, read(e->CallFloatMethod(boxed, unbox)));
+    case 'D': return boxDouble(e, read(e->CallDoubleMethod(boxed, unbox)));
+    default: return read(e->CallObjectMethod(boxed, unbox));
+  }
+}
+
+jobject suspendedCall(JNIEnv* e, jobject continuation, const std::function<void(Resume)>& start) {
+  static jclass intrinsics = findClass("kotlin/coroutines/intrinsics/IntrinsicsKt");
+  static jmethodID intercepted = staticMethod(
+      intrinsics, "intercepted", "(Lkotlin/coroutines/Continuation;)Lkotlin/coroutines/Continuation;");
+  static jclass safeClass = findClass("kotlin/coroutines/SafeContinuation");
+  static jmethodID safeInit = method(safeClass, "<init>", "(Lkotlin/coroutines/Continuation;)V");
+  static jmethodID getOrThrow = method(safeClass, "getOrThrow", "()Ljava/lang/Object;");
+  static jmethodID resumeWith = method(safeClass, "resumeWith", "(Ljava/lang/Object;)V");
+  static jclass results = findClass("kotlin/ResultKt");
+  static jmethodID failure = staticMethod(results, "createFailure", "(Ljava/lang/Throwable;)Ljava/lang/Object;");
+
+  // As suspendCoroutine does: resumed through its dispatcher, never on the Lucent thread,
+  // and a result that arrives before the call returns is its result.
+  jobject dispatched = e->CallStaticObjectMethod(intrinsics, intercepted, continuation);
+  check(e);
+  jobject local = e->NewObject(safeClass, safeInit, dispatched);
+  e->DeleteLocalRef(dispatched);
+  check(e);
+  auto safe = std::make_shared<NativeRef>(wrap(e, e->NewLocalRef(local), "a continuation"));
+
+  // Kotlin's Result is the value itself, or a failure of the Throwable.
+  start([safe](JNIEnv* env, jobject value, const Error* error) {
+    jobject result = value;
+    if (error) {
+      jthrowable t = throwableOf(env, *error);
+      result = env->CallStaticObjectMethod(results, failure, t);
+      env->DeleteLocalRef(t);
+      check(env);
+    }
+    env->CallVoidMethod(unwrap(*safe), resumeWith, result);
+    if (error) env->DeleteLocalRef(result);
+    check(env);
+  });
+
+  // COROUTINE_SUSPENDED, or the result already there; a failure already there stays pending.
+  jobject r = e->CallObjectMethod(local, getOrThrow);
+  e->DeleteLocalRef(local);
+  return r;
+}
+
+jobject unit(JNIEnv* e) {
+  static jclass cls = findClass("kotlin/Unit");
+  static jfieldID instance = staticField(cls, "INSTANCE", "Lkotlin/Unit;");
+  return e->GetStaticObjectField(cls, instance);
+}
+
 void rethrowPending(JNIEnv* e) {
   jthrowable t = e->ExceptionOccurred();
   e->ExceptionClear();
   throw Exception(errorOf(e, t));
 }
 
-Error errorOf(JNIEnv* e, jobject t) {
-  if (auto own = t ? takeThrown(e, t) : std::nullopt) return std::move(*own);
+namespace {
+
+/// A Java exception as a Lucent error; a Lucent error it carries is
+/// removed from the list when `take`.
+Error errorOf(JNIEnv* e, jobject t, bool take) {
+  if (auto own = t ? findThrown(e, t, take) : std::nullopt) return std::move(*own);
   if (!t) {
     // No exception to read: a cancelled task.
     Error err = makeError(String::fromLatin1("Error"), String::fromLatin1("cancelled"));
     err->code = String::fromLatin1("java.util.concurrent.CancellationException");
     return err;
   }
-  jclass objectCls = e->FindClass("java/lang/Object");
-  jobject cls = e->CallObjectMethod(t, e->GetMethodID(objectCls, "getClass", "()Ljava/lang/Class;"));
-  jclass classCls = e->FindClass("java/lang/Class");
-  auto name = static_cast<jstring>(e->CallObjectMethod(cls, e->GetMethodID(classCls, "getName", "()Ljava/lang/String;")));
-  jclass throwableCls = e->FindClass("java/lang/Throwable");
-  auto message = static_cast<jstring>(e->CallObjectMethod(t, e->GetMethodID(throwableCls, "getMessage", "()Ljava/lang/String;")));
-  e->ExceptionClear();
+  // These throw only when out of memory, which leaves the defaults below:
+  // cleared after each call, before the next JNI call (as CheckJNI requires).
+  auto read = [e](jobject o, const char* cls, const char* name, const char* sig) {
+    jobject r = e->CallObjectMethod(o, e->GetMethodID(e->FindClass(cls), name, sig));
+    e->ExceptionClear();
+    return r;
+  };
+  jobject cls = read(t, "java/lang/Object", "getClass", "()Ljava/lang/Class;");
+  auto name = static_cast<jstring>(cls ? read(cls, "java/lang/Class", "getName", "()Ljava/lang/String;") : nullptr);
+  auto message = static_cast<jstring>(read(t, "java/lang/Throwable", "getMessage", "()Ljava/lang/String;"));
   String className = name ? fromJString(e, name, "") : String::fromLatin1("java.lang.Throwable");
   Error err = makeError(String::fromLatin1("Error"), message ? fromJString(e, message, "") : className);
   err->code = className;
   return err;
 }
 
+}  // namespace
+
+Error errorOf(JNIEnv* e, jobject t) { return errorOf(e, t, true); }
+
+Error errorOf(const NativeRef& throwable) { return errorOf(env(), unwrap(throwable), false); }
+
 void close(const NativeRef& closeable) {
   JNIEnv* e = env();
   static jmethodID m = method(findClass("java/lang/AutoCloseable"), "close", "()V");
@@ -566,6 +696,7 @@ jobject boxDouble(JNIEnv* e, jdouble v) { return boxWith(e, "java/lang/Double",
 jobject boxFloat(JNIEnv* e, jfloat v) { return boxWith(e, "java/lang/Float", "(F)Ljava/lang/Float;", jvalue{.f = v}); }
 jobject boxBoolean(JNIEnv* e, bool v) { return boxWith(e, "java/lang/Boolean", "(Z)Ljava/lang/Boolean;", jvalue{.z = static_cast<jboolean>(v ? JNI_TRUE : JNI_FALSE)}); }
 
+#ifdef __ANDROID__
 NativeRef appContext() {
   static NativeRef* app = [] {
     JNIEnv* e = env();
@@ -581,6 +712,7 @@ NativeRef appContext() {
   }();
   return *app;
 }
+#endif
 
 namespace {
 thread_local jobject hostingView = nullptr;
@@ -601,6 +733,7 @@ Opt<NativeRef> hostContext() {
   return wrapOpt(e, context);
 }
 
+#ifdef __ANDROID__
 bool available(double api) {
   static int level = [] {
     char value[PROP_VALUE_MAX] = {0};
@@ -609,9 +742,11 @@ bool available(double api) {
   }();
   return level >= api;
 }
+#endif
 
 }  // namespace lucent::jni
 
+#ifdef __ANDROID__
 namespace lucent {
 
 void postToMain(std::function<void()> job) {
@@ -646,5 +781,6 @@ bool onMainThread() {
 }
 
 }  // namespace lucent
+#endif
 
-#endif  // __ANDROID__
+#endif

package/runtime/cpp/lucent/platform/android.h

@@ -37,6 +37,9 @@ inline void check(JNIEnv* env) {
 }
 /// A Java exception (a Throwable) as a Lucent error, coded as rethrowPending does.
 Error errorOf(JNIEnv* env, jobject throwable);
+/// `errorOf(throwable)` from lucent:android: the same error, but a Lucent
+/// error the exception carries stays with it, for the next call to read.
+Error errorOf(const NativeRef& throwable);
 
 /// Closes an AutoCloseable (a Closeable, a Cursor…): how a `using`
 /// declaration disposes one. Throws what close() throws.
@@ -204,12 +207,80 @@ jobject boxDouble(JNIEnv* env, jdouble v);
 jobject boxFloat(JNIEnv* env, jfloat v);
 jobject boxBoolean(JNIEnv* env, bool v);
 
+/**
+ * A Kotlin value class `cls` (`dev/x/Score`) the JVM passes as its
+ * underlying value, whose descriptor is `underlying` (`I`): its boxed
+ * object of `value` (boxed itself, as a proxy receives it: an Integer),
+ * through the class's `box-impl`; and the underlying value of a boxed
+ * object, boxed as a proxy returns it, through its `unbox-impl`. Local
+ * references.
+ */
+jobject boxValueClass(JNIEnv* env, const char* cls, const char* underlying, jobject value);
+jobject unboxValueClass(JNIEnv* env, const char* cls, const char* underlying, jobject boxed);
+
 // --- Kotlin coroutines through generated shims ----------------------------------------
 
-/// Throws `error` to Java as a java.lang.RuntimeException carrying its
-/// message, which errorOf reads back as `error` itself.
+/// `error` as a java.lang.RuntimeException carrying its message, which
+/// errorOf reads back as `error` itself. A local reference.
+jthrowable throwableOf(JNIEnv* env, Error error);
+
+/// Throws `error` to Java, as throwableOf makes it.
 void throwToJava(JNIEnv* env, Error error);
 
+/**
+ * How a Kotlin suspend function a Lucent class implements ends: resumes
+ * its continuation with a value (a Java object, or null), or with the
+ * error (see throwableOf). Any thread may call it, once.
+ */
+using Resume = std::function<void(JNIEnv* env, jobject value, const Error* error)>;
+
+/**
+ * A suspend function a Lucent class implements, called through a proxy
+ * with `continuation` (its last argument): `start` is given what resumes
+ * it, and Kotlin is told the call suspended (COROUTINE_SUSPENDED), whose
+ * result it waits for.
+ */
+jobject suspendedCall(JNIEnv* env, jobject continuation, const std::function<void(Resume)>& start);
+
+/// Kotlin's Unit, what a suspend function giving nothing resumes with. A local reference.
+jobject unit(JNIEnv* env);
+
+/**
+ * Resumes a suspend call (`resume`) with what `call` gives: a promise's
+ * outcome once it settles, else its value now; what it throws is its
+ * error. `box(env, value)` makes the Java object of a value. On the
+ * Lucent thread, where the call runs.
+ */
+template <class F, class B>
+void resumeWithResult(const Resume& resume, F call, B box) {
+  auto settle = [resume, box](const auto& value) {
+    JNIEnv* e = env();
+    LocalFrame frame(e);
+    resume(e, box(e, value), nullptr);
+  };
+  auto fail = [resume](const Error& error) {
+    JNIEnv* e = env();
+    LocalFrame frame(e);
+    resume(e, nullptr, &error);
+  };
+
+  try {
+    auto r = call();
+    if constexpr (IsPromise<decltype(r)>::value) {
+      r.onSettled([r, settle, fail] {
+        if (r.fulfilled())
+          settle(r.value());
+        else
+          fail(r.error());
+      });
+    } else {
+      settle(r);
+    }
+  } catch (...) {
+    fail(currentError(std::current_exception()));
+  }
+}
+
 /**
  * A Lucent function a generated shim runs as a Kotlin suspend function (a
  * suspend function argument, a fun interface's suspending function), which
@@ -291,6 +362,12 @@ NativeRef appContext();
 /// outside any setup.
 Opt<NativeRef> hostContext();
 
+/// The Context a view is made with: the hosting view's (its Activity's theme), else the app's.
+inline NativeRef viewContext() {
+  Opt<NativeRef> host = hostContext();
+  return host.has() ? host.get() : appContext();
+}
+
 /**
  * While one lives, `view` (a local reference) hosts the mount whose setup
  * runs on this thread, and hostContext() is its context: the Android host

package/runtime/cpp/lucent/platform/ios.h

@@ -90,6 +90,13 @@ NSArray* toNSArray(const Array<T>& a, F toObject) {
   }
   return out;
 }
+/// An array of `items` (objects, never nil): a Swift tuple's elements, as its shim takes them.
+template <class... T>
+NSArray* toNSArrayOf(T... items) {
+  id all[] = {items...};
+  return [NSArray arrayWithObjects:all count:sizeof...(T)];
+}
+
 template <class T, class F>
 Array<T> fromNSArray(NSArray* a, F fromObject, const char* what) {
   if (!a) returnedNil(what);

package/runtime/cpp/lucent/platform/ios_ui.h

@@ -189,4 +189,24 @@ Fn<void()> onAppEvent(const String& event, Fn<void()> listener, Opt<AbortSignal>
 /// scene's session's persistent identifier.
 Fn<void()> onSceneEvent(const String& event, Fn<void(String)> listener, Opt<AbortSignal> signal = {});
 
+/**
+ * Calls `handler` with the control on each of `events` (a UIControlEvents
+ * mask): a JSX element's control event (T48), as the UIAction UIKit
+ * registers. Gives the action, for removeControlAction: the control keeps
+ * it, and through it the handler, until then.
+ */
+template <class Handler>
+NativeRef addControlAction(id control, NSUInteger events, Handler handler) {
+  UIAction* action = [UIAction actionWithHandler:^(UIAction* a) {
+    handler(a.sender);
+  }];
+  [(UIControl*)control addAction:action forControlEvents:(UIControlEvents)events];
+  return wrap(action, "a control's action");
+}
+
+/** Takes back an action addControlAction registered. */
+inline void removeControlAction(id control, const NativeRef& action, NSUInteger events) {
+  [(UIControl*)control removeAction:(UIAction*)unwrap(action) forControlEvents:(UIControlEvents)events];
+}
+
 }  // namespace lucent::objc

package/runtime/cpp/rn/LucentComponentView.mm

@@ -286,6 +286,18 @@ void inMainContext(const char* where, F&& work) {
         LucentComponentView *view = weakSelf;
 
         return view ? [view lucentMeasure:constraints] : std::nullopt;
+      },
+      // The content changed, a native timer's or an animation's code too, not
+      // only a commit's or a command's: it may have moved the slot, which lays
+      // out again on UIKit's next pass and reports where it is, past the
+      // reports' bound (TA26).
+      [weakSelf] {
+        LucentComponentView *view = weakSelf;
+
+        if (!view) return;
+
+        view->_place.contentChanged();
+        [view->_children.slot setNeedsLayout];
       });
   _place.start(static_cast<float>(RCTScreenScale()), static_cast<int>(self.tag));
   [self.lucentChildren startMount];

package/runtime/cpp/rn/LucentViewSizing.h

@@ -199,11 +199,15 @@ class HostSizing {
 
   /// A mount starts on the view `tag` names, at `scale` pixels per point,
   /// its content measured by `measure`: revision 1, measured from scratch.
-  void start(float scale, int tag, Measure measure) {
+  /// `changed`, if any, runs after each change of the content is measured:
+  /// what else the host follows the content for (its slot, which the
+  /// content may have moved).
+  void start(float scale, int tag, Measure measure, std::function<void()> changed = nullptr) {
     measurer_ = sizing::Measurer(scale);
     lastPost_.reset();
     tag_ = tag;
     measure_ = std::move(measure);
+    changed_ = std::move(changed);
     content_ = ui::Content::create([this] { contentChanged(); });
     traceSizing("%d start", tag_);
   }
@@ -214,6 +218,7 @@ class HostSizing {
 
     content_.reset();
     measure_ = nullptr;
+    changed_ = nullptr;
     state_.reset();
     lastPost_.reset();
   }
@@ -246,6 +251,8 @@ class HostSizing {
     measurer_.contentChanged();
     traceSizing("%d content rev %llu", tag_, static_cast<unsigned long long>(measurer_.revision()));
     measure();
+
+    if (changed_) changed_();
   }
 
   /// Measures if the state asks for constraints this content revision has
@@ -338,6 +345,7 @@ class HostSizing {
   sizing::Measurer measurer_;
   std::optional<Post> lastPost_;
   Measure measure_;
+  std::function<void()> changed_;
   std::shared_ptr<ui::Content> content_;
   int tag_ = 0;
 };