@oxyhq/bloom 1.1.0 → 1.2.1

package/lib/module/media-flight/constants.js

@@ -0,0 +1,35 @@
+"use strict";
+
+/**
+ * How long `flyTo` will wait for `<MediaFlightLayer>` to commit the surface
+ * before letting the caller carry on regardless (ms).
+ *
+ * The wait is a COMMIT, not a network round-trip: the surface only has to be
+ * mounted, because that is what puts it in expo-video's `_mountedVideos` set
+ * while the origin is still there — which is the whole mechanism that carries
+ * `currentTime` across. One React commit is a frame or two. Painting is a
+ * separate, slower thing that the poster covers (see `MediaSurface`), so it is
+ * deliberately NOT waited on here: blocking a tap on a decode would trade a
+ * problem nobody can see for one everybody can feel.
+ *
+ * The timeout exists for the case where no layer is mounted at all. Without it
+ * the promise never settles and the consumer never navigates — an app that
+ * forgot one line at its root would appear to have a dead feed.
+ */
+export const SURFACE_MOUNT_TIMEOUT_MS = 250;
+
+/*
+ * There is deliberately NO hand-off timeout.
+ *
+ * The obvious one — release the flying surface after N seconds if no destination
+ * ever claims it — would have to be wrong in one direction or the other, because
+ * the layer cannot tell "the destination failed" from "the caller meant the
+ * layer to keep painting this". And the failure it would guard against is not
+ * actually bad: a destination that never loads leaves the flying surface
+ * showing the video, playing, at exactly the rect the destination wanted, over a
+ * destination showing its poster. Going back calls `flyBack`, which releases it.
+ *
+ * `flyBack(id)` and `releaseFlight(id)` are the escape hatches, and they are
+ * the caller's to use.
+ */
+//# sourceMappingURL=constants.js.map

package/lib/module/media-flight/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["SURFACE_MOUNT_TIMEOUT_MS"],"sourceRoot":"../../../src","sources":["media-flight/constants.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMA,wBAAwB,GAAG,GAAG;;AAE3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","ignoreList":[]}

package/lib/module/media-flight/expo-video-module.js

@@ -0,0 +1,173 @@
+"use strict";
+
+/**
+ * The optional-peer boundary for `expo-video`.
+ *
+ * Bloom ships no native code and never will, so `expo-video` cannot be a hard
+ * dependency: an app that renders no video must not be made to install a native
+ * module. It is therefore an OPTIONAL peer, and a static `import` contradicts
+ * that — Metro resolves every static import in the eager graph, so an omitted
+ * "optional" peer does not degrade, it aborts the whole bundle with `Unable to
+ * resolve module expo-video`, naming a package the app never mentions.
+ *
+ * The load has to be dynamic in the ONE shape Metro understands: a `require()`
+ * of a STRING LITERAL as a DIRECT STATEMENT of a `try` block, which Metro
+ * collects as an optional dependency (resolving the real module when installed,
+ * writing `null` into the dependency map when it is not, so the failure lands in
+ * the `catch` below at evaluation time instead of at build time). One `if` of
+ * nesting loses that — `isOptionalDependency` returns at the FIRST BlockStatement
+ * it meets — hence the `typeof require` guard sits OUTSIDE the try.
+ *
+ * `require` may also not exist at all (this file backs the `import` condition
+ * too, i.e. an ESM build under Node), hence that guard.
+ *
+ * A missing video module is invisible — a poster where a video should be looks
+ * exactly like a video that has not started — so {@link warnExpoVideoUnavailable}
+ * names the package once, in dev.
+ *
+ * @see connection-status/netinfo.ts — the same boundary for netinfo.
+ * @see hooks/haptics-module.ts — the same boundary for expo-haptics.
+ */
+
+/**
+ * Declared locally rather than taken from the ambient `NodeRequire`, which
+ * returns `any`: `unknown` forces the module handle to be narrowed below instead
+ * of leaking an untyped value into the caller.
+ */
+
+/**
+ * The slice of `expo-video`'s `VideoPlayer` Bloom depends on.
+ *
+ * Hand-written rather than `typeof import('expo-video')` so no expo-video type
+ * reaches Bloom's emitted declarations — a consumer that skips the optional peer
+ * must not inherit a TS7016 from Bloom's own `.d.ts`. The two are kept in step by
+ * the assignability check in `__tests__/MediaFlight.test.tsx`, which is excluded
+ * from the build and so may name the real package.
+ *
+ * Bloom never CALLS any of this. **The consumer creates the player, owns it and
+ * destroys it**; Bloom only hands the object back to a `VideoView`, which is the
+ * whole mechanism that lets a video move between surfaces without restarting
+ * (expo-video's own docs: "when the same player is playing in multiple video
+ * views"). The three members below exist so the type is not `object` — a
+ * structural minimum the real `VideoPlayer` satisfies, and that an arbitrary
+ * object does not.
+ *
+ * `play`/`pause` are declared in METHOD syntax deliberately: `strictFunctionTypes`
+ * exempts method parameters from contravariance, which keeps a real
+ * `VideoPlayer` assignable here across `@types/react` copies.
+ */
+
+/** How a video is scaled inside its box. Mirrors expo-video's `VideoContentFit`. */
+
+/**
+ * Android's rendering surface for a video view.
+ *
+ * `textureView` is what Bloom asks for everywhere, because a `SurfaceView` is
+ * composited by the system OUTSIDE the app's view hierarchy: it ignores the
+ * parent's clip, corner radius and transform, so a video flying between two
+ * rects would paint as an un-rounded rectangle at the wrong place. It also
+ * cannot be changed at runtime (expo-video: "This prop should not be changed at
+ * runtime"), which is why {@link MediaSurfaceProps.surfaceType} is captured on
+ * first render.
+ */
+
+/** The slice of `VideoViewProps` Bloom passes. */
+
+/** The slice of expo-video's module surface Bloom renders. */
+
+/** `undefined` until the first load attempt, then the module or `null`. */
+let videoModule;
+/** Set by {@link provideExpoVideo}; wins over the `require` below. */
+let providedModule;
+/** Why the load failed, quoted verbatim in the dev warning. */
+let unavailableReason = '';
+let hasWarned = false;
+
+/**
+ * Hand Bloom the expo-video module explicitly.
+ *
+ * REQUIRED ON ANY ESM WEB BUNDLER, and measured rather than assumed: in a Vite
+ * bundle `typeof require` is `undefined`, so the optional-peer `require` below
+ * cannot run and video silently degrades to its poster **even when expo-video
+ * is installed**. Metro has a real `require` and is unaffected, which is why
+ * this went unnoticed — the app that uses this is Metro-built.
+ *
+ * There is no bundler-agnostic sync alternative: `import()` is async and this is
+ * called during render, so making it async would mean the surface renders
+ * without video for a frame and then upgrades. Handing the module over is
+ * explicit, synchronous, and costs the consumer one line at startup:
+ *
+ * ```ts
+ * import * as ExpoVideo from 'expo-video';
+ * provideExpoVideo(ExpoVideo);
+ * ```
+ *
+ * Pass `null` to clear it.
+ */
+export function provideExpoVideo(module) {
+  providedModule = module;
+  // Drop any cached `require` result so the next load reflects this decision.
+  videoModule = undefined;
+}
+
+/** The expo-video module, or `null` when the optional peer is not installed. */
+export function loadExpoVideo() {
+  if (providedModule !== undefined && providedModule !== null) return providedModule;
+  if (videoModule !== undefined) return videoModule;
+  videoModule = null;
+
+  // The `typeof require` guard sits OUTSIDE the try on purpose — see the header.
+  // Nested one `if`/`else` deeper, the require below is no longer a direct
+  // statement of the try block, Metro stops marking it optional, and an app
+  // without expo-video fails to BUILD instead of losing the video surface.
+  if (typeof require === 'undefined') {
+    unavailableReason = 'this bundle has no CommonJS `require`';
+    return videoModule;
+  }
+  try {
+    const loaded = require('expo-video');
+    // `VideoView` is a class component upstream, so `typeof` is `'function'`
+    // either way; a memo/forwardRef build would be an object carrying
+    // `$$typeof`. Both are accepted, nothing else is.
+    const resolved = isComponentBearing(loaded) ? loaded : loaded?.default;
+    if (isComponentBearing(resolved)) {
+      videoModule = {
+        VideoView: resolved.VideoView
+      };
+    } else {
+      unavailableReason = 'the module resolved without a `VideoView` export';
+    }
+  } catch (error) {
+    unavailableReason = error instanceof Error ? error.message : String(error);
+  }
+  return videoModule;
+}
+function isComponentBearing(candidate) {
+  const view = candidate?.VideoView;
+  if (typeof view === 'function') return true;
+  return typeof view === 'object' && view !== null && '$$typeof' in view;
+}
+
+/**
+ * One warning per module lifetime, and none in production — the same mechanism
+ * as `connection-status/netinfo.ts` and `hooks/haptics-module.ts`. Metro and
+ * Vite/Rolldown both fold the `NODE_ENV` check statically, so a production
+ * bundle keeps neither the branch nor the message.
+ */
+export function warnExpoVideoUnavailable() {
+  if (process.env.NODE_ENV === 'production' || hasWarned) return;
+  hasWarned = true;
+  // Internal Bloom diagnostic: only the consumer's package.json can fix this,
+  // so it names the package, the install command and what is lost.
+  // eslint-disable-next-line no-console
+  console.warn('[Bloom] A video media surface fell back to its poster: the optional peer ' + '`expo-video` could not be loaded, so no video is rendered and the shared ' + 'media transition carries a still frame instead. Install it ' + '(`npx expo install expo-video`) or pass image content only. ' + `Reason: ${unavailableReason}`);
+}
+
+/** Test seam — drops the cached module handle so a suite can load it again. */
+export function resetExpoVideoModule() {
+  videoModule = undefined;
+  providedModule = undefined;
+  unavailableReason = '';
+  hasWarned = false;
+}
+//# sourceMappingURL=expo-video-module.js.map

package/lib/module/media-flight/expo-video-module.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["videoModule","providedModule","unavailableReason","hasWarned","provideExpoVideo","module","undefined","loadExpoVideo","require","loaded","resolved","isComponentBearing","default","VideoView","error","Error","message","String","candidate","view","warnExpoVideoUnavailable","process","env","NODE_ENV","console","warn","resetExpoVideoModule"],"sourceRoot":"../../../src","sources":["media-flight/expo-video-module.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAIA;AACA;AACA;AACA;AACA;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAOA;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAGA;;AAkBA;;AAKA;AACA,IAAIA,WAA6C;AACjD;AACA,IAAIC,cAAgD;AACpD;AACA,IAAIC,iBAAiB,GAAG,EAAE;AAC1B,IAAIC,SAAS,GAAG,KAAK;;AAErB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,gBAAgBA,CAACC,MAA4B,EAAQ;EACnEJ,cAAc,GAAGI,MAAM;EACvB;EACAL,WAAW,GAAGM,SAAS;AACzB;;AAEA;AACA,OAAO,SAASC,aAAaA,CAAA,EAAyB;EACpD,IAAIN,cAAc,KAAKK,SAAS,IAAIL,cAAc,KAAK,IAAI,EAAE,OAAOA,cAAc;EAClF,IAAID,WAAW,KAAKM,SAAS,EAAE,OAAON,WAAW;EACjDA,WAAW,GAAG,IAAI;;EAElB;EACA;EACA;EACA;EACA,IAAI,OAAOQ,OAAO,KAAK,WAAW,EAAE;IAClCN,iBAAiB,GAAG,uCAAuC;IAC3D,OAAOF,WAAW;EACpB;EAEA,IAAI;IACF,MAAMS,MAAM,GAAGD,OAAO,CAAC,YAAY,CAGtB;IACb;IACA;IACA;IACA,MAAME,QAAQ,GAAGC,kBAAkB,CAACF,MAAM,CAAC,GAAGA,MAAM,GAAGA,MAAM,EAAEG,OAAO;IAEtE,IAAID,kBAAkB,CAACD,QAAQ,CAAC,EAAE;MAChCV,WAAW,GAAG;QAAEa,SAAS,EAAEH,QAAQ,CAACG;MAA+C,CAAC;IACtF,CAAC,MAAM;MACLX,iBAAiB,GAAG,kDAAkD;IACxE;EACF,CAAC,CAAC,OAAOY,KAAK,EAAE;IACdZ,iBAAiB,GAAGY,KAAK,YAAYC,KAAK,GAAGD,KAAK,CAACE,OAAO,GAAGC,MAAM,CAACH,KAAK,CAAC;EAC5E;EAEA,OAAOd,WAAW;AACpB;AAEA,SAASW,kBAAkBA,CACzBO,SAA8E,EACU;EACxF,MAAMC,IAAI,GAAGD,SAAS,EAAEL,SAAS;EACjC,IAAI,OAAOM,IAAI,KAAK,UAAU,EAAE,OAAO,IAAI;EAC3C,OAAO,OAAOA,IAAI,KAAK,QAAQ,IAAIA,IAAI,KAAK,IAAI,IAAI,UAAU,IAAIA,IAAI;AACxE;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,wBAAwBA,CAAA,EAAS;EAC/C,IAAIC,OAAO,CAACC,GAAG,CAACC,QAAQ,KAAK,YAAY,IAAIpB,SAAS,EAAE;EACxDA,SAAS,GAAG,IAAI;EAChB;EACA;EACA;EACAqB,OAAO,CAACC,IAAI,CACV,2EAA2E,GACzE,2EAA2E,GAC3E,6DAA6D,GAC7D,8DAA8D,GAC9D,WAAWvB,iBAAiB,EAChC,CAAC;AACH;;AAEA;AACA,OAAO,SAASwB,oBAAoBA,CAAA,EAAS;EAC3C1B,WAAW,GAAGM,SAAS;EACvBL,cAAc,GAAGK,SAAS;EAC1BJ,iBAAiB,GAAG,EAAE;EACtBC,SAAS,GAAG,KAAK;AACnB","ignoreList":[]}

package/lib/module/media-flight/index.js

@@ -0,0 +1,9 @@
+"use strict";
+
+export { MediaFlightLayer } from "./MediaFlightLayer.js";
+export { MediaSurface, MediaPoster, EmptyMediaSurface } from "./MediaSurface.js";
+export { useMediaFlight } from "./use-media-flight.js";
+export { DEFAULT_FLIGHT_CORNER_RADIUS, flightProgress, handOffFlight, hasFlight, releaseFlight, resetMediaFlight } from "./store.js";
+export { SURFACE_MOUNT_TIMEOUT_MS } from "./constants.js";
+export { loadExpoVideo, warnExpoVideoUnavailable, provideExpoVideo, resetExpoVideoModule } from "./expo-video-module.js";
+//# sourceMappingURL=index.js.map

package/lib/module/media-flight/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["MediaFlightLayer","MediaSurface","MediaPoster","EmptyMediaSurface","useMediaFlight","DEFAULT_FLIGHT_CORNER_RADIUS","flightProgress","handOffFlight","hasFlight","releaseFlight","resetMediaFlight","SURFACE_MOUNT_TIMEOUT_MS","loadExpoVideo","warnExpoVideoUnavailable","provideExpoVideo","resetExpoVideoModule"],"sourceRoot":"../../../src","sources":["media-flight/index.ts"],"mappings":";;AAAA,SAASA,gBAAgB,QAAQ,uBAAoB;AACrD,SAASC,YAAY,EAAEC,WAAW,EAAEC,iBAAiB,QAAQ,mBAAgB;AAC7E,SAASC,cAAc,QAAQ,uBAAoB;AACnD,SACEC,4BAA4B,EAC5BC,cAAc,EACdC,aAAa,EACbC,SAAS,EACTC,aAAa,EACbC,gBAAgB,QACX,YAAS;AAChB,SAASC,wBAAwB,QAAQ,gBAAa;AACtD,SACEC,aAAa,EACbC,wBAAwB,EACxBC,gBAAgB,EAChBC,oBAAoB,QAMf,wBAAqB","ignoreList":[]}

package/lib/module/media-flight/store.js

@@ -0,0 +1,439 @@
+"use strict";
+
+/**
+ * The media-flight registry: anchors, live surfaces, and the animation that
+ * moves them.
+ *
+ * ## Why the animation lives HERE and not in the layer
+ *
+ * A flight is started by an imperative call (`flyTo`) from a screen that may be
+ * about to unmount. If the layer drove the animation from an effect keyed on the
+ * flight record, the first frame would be one commit late — and on web, where
+ * the origin route is genuinely gone by the next commit, that frame is the one
+ * the user sees. Driving the shared value at the call site makes the leg start
+ * exactly when the caller says it does and leaves the layer a pure painter.
+ *
+ * The shared values are created with `makeMutable` rather than `useSharedValue`
+ * for the same reason: they belong to a flight, not to a component, and the
+ * component that paints a flight is not the one that starts it.
+ *
+ * ## Why the registry is anchored on `globalThis`
+ *
+ * Same reason as the portal group and the overlay stack: `exports` ships a
+ * `react-native` → `src` condition beside the `lib/module` and `lib/commonjs`
+ * forks, and a bundler can resolve `@oxyhq/bloom/media-flight` through different
+ * conditions from different call sites. Two physical copies of this module would
+ * each keep their own registry, and the `<MediaFlightLayer>` mounted at the app
+ * root would never see the flight a screen started.
+ */
+import { Platform } from 'react-native';
+import { Easing, makeMutable, runOnJS, withSpring, withTiming } from 'react-native-reanimated';
+import { RADIUS } from "../design-tokens/index.js";
+import { SURFACE_MOUNT_TIMEOUT_MS } from "./constants.js";
+import { CLOSE_DURATION_WEB, CLOSE_SPRING, OPEN_DURATION_WEB, OPEN_SPRING } from "../zoomable-media-gallery/constants.js";
+/**
+ * Default corner radius of a flying box — Bloom's `radius-12`, the same value
+ * the media gallery fits its media at, so a flight that lands in the gallery
+ * lands on an identical shape.
+ */
+export const DEFAULT_FLIGHT_CORNER_RADIUS = RADIUS['radius-12'];
+
+/**
+ * Bookkeeping the layer does not RENDER, kept out of the `MediaFlight` record
+ * on purpose.
+ *
+ * The record is replaced on every visual change so its identity tells React the
+ * leg moved; folding these flags into it would churn that identity on events
+ * nobody paints, and folding the record into these would put mutable state back
+ * in a rendered position. They are separate because they answer to different
+ * consumers.
+ */
+
+function emptyRegistry() {
+  return {
+    anchors: new Map(),
+    flights: new Map(),
+    status: new Map(),
+    listeners: new Set(),
+    snapshot: [],
+    progress: makeMutable(0)
+  };
+}
+function statusFor(id) {
+  const reg = registry();
+  let status = reg.status.get(id);
+  if (!status) {
+    status = {
+      mounted: false,
+      settled: false,
+      handedOff: false,
+      mountWaiters: [],
+      mountTimer: null
+    };
+    reg.status.set(id, status);
+  }
+  return status;
+}
+function clearTimers(status) {
+  if (status.mountTimer !== null) clearTimeout(status.mountTimer);
+  status.mountTimer = null;
+}
+function resolveMountWaiters(status) {
+  const waiters = status.mountWaiters;
+  status.mountWaiters = [];
+  if (status.mountTimer !== null) {
+    clearTimeout(status.mountTimer);
+    status.mountTimer = null;
+  }
+  for (const waiter of waiters) waiter();
+}
+function registry() {
+  globalThis.__oxyhq_bloom_media_flight__ ??= emptyRegistry();
+  return globalThis.__oxyhq_bloom_media_flight__;
+}
+function publish(reg) {
+  reg.snapshot = [...reg.flights.values()];
+  for (const listener of reg.listeners) listener();
+}
+
+/** Subscribe to the live-surface set. The layer's `useSyncExternalStore` half. */
+export function subscribeToFlights(listener) {
+  const reg = registry();
+  reg.listeners.add(listener);
+  return () => {
+    reg.listeners.delete(listener);
+  };
+}
+
+/** The live surfaces, oldest first. Stable identity between changes. */
+export function getFlights() {
+  return registry().snapshot;
+}
+
+/** The shared progress value of the most recent leg. */
+export function flightProgress() {
+  return registry().progress;
+}
+
+/**
+ * Register (or clear) the node that anchors `id`.
+ *
+ * A `Map` re-insertion moves the key to the end, which is what makes "the most
+ * recently registered node is the anchor" true even when an origin screen's
+ * callback ref fires again after the destination has registered.
+ */
+export function registerAnchor(id, node) {
+  const reg = registry();
+  reg.anchors.delete(id);
+  if (node !== null) reg.anchors.set(id, node);
+}
+export function measureAnchor(id) {
+  const node = registry().anchors.get(id);
+  if (!node) return Promise.resolve(null);
+  return new Promise(resolve => {
+    node.measureInWindow((x, y, width, height) => {
+      // A zero-area measurement is what a node reports while it is laid out but
+      // not yet on screen. Flying to it would collapse the surface to a point,
+      // so it reads as "no anchor" and the caller skips the transition.
+      resolve(width > 0 && height > 0 ? {
+        x,
+        y,
+        width,
+        height
+      } : null);
+    });
+  });
+}
+
+/** Whether a surface is currently live for `id`. */
+export function hasFlight(id) {
+  return registry().flights.has(id);
+}
+
+/**
+ * Take the surface for `id` live (if it is not already) and move it to `rect`.
+ *
+ * Retargeting mid-flight keeps the SAME `MediaFlight` record — and therefore the
+ * same mounted `VideoView` — which is the whole point. A second record would be
+ * a second surface for one id, and swapping between them is exactly the remount
+ * that restarts playback.
+ *
+ * ## Why it returns a promise, and what the promise means
+ *
+ * It resolves once the layer has COMMITTED a surface for this id — not once
+ * that surface has painted.
+ *
+ * The distinction is the whole ordering contract. expo-video's web player keeps
+ * a `Set` of mounted `<video>` elements and, on each mount, copies
+ * `currentTime`, play state, volume, muted and rate from `[...set][0]`. If the
+ * set is EMPTY when the new element mounts, it returns early and the element
+ * starts at zero — a restart. So the layer's surface has to enter that set while
+ * the origin's is still in it, which means the caller must not tear the origin
+ * down (on web: must not navigate) until this promise resolves.
+ *
+ * That knowledge lives here rather than in the caller, which is the point: a
+ * consumer that has to know the mount order is a consumer that will get it wrong
+ * once and produce an intermittent restart nobody can reproduce locally.
+ *
+ * Painting is deliberately NOT waited on. `MediaSurface` renders the poster
+ * BEHIND the video on both platforms, and neither an unpainted `<video>` (no
+ * `poster` attribute is set) nor an Android `TextureView` with the ExoPlayer
+ * shutter off draws anything opaque — so the still shows through until the first
+ * frame lands, and there is no black box to hide. Waiting for a decode would
+ * trade an invisible problem for a laggy tap.
+ */
+export function flyTo(id, rect, content, options) {
+  const reg = registry();
+  const existing = reg.flights.get(id);
+  if (existing) {
+    // A retarget REPLACES the record rather than mutating it. Identity is what
+    // tells React (and the React Compiler) that the leg changed: a mutated
+    // record has the same identity, so a memoized read of `flight.from` would
+    // keep returning the previous leg's origin forever — the exact
+    // external-mutable-state stale read the compiler is documented to produce.
+    // The shared value is carried over untouched, so the surface resumes rather
+    // than restarting.
+    const next = {
+      ...existing,
+      // The leg that was running is abandoned where it stands: `from` becomes
+      // the rect the surface is CURRENTLY at, so a retarget never snaps.
+      from: interpolateRect(existing.from, existing.to, existing.progress.value),
+      to: rect,
+      content,
+      cornerRadius: options?.cornerRadius ?? existing.cornerRadius,
+      contentFit: options?.contentFit ?? existing.contentFit,
+      // NOT retargetable: `MediaSurface` captures it on first render because
+      // expo-video forbids changing it at runtime, so a new value here would be
+      // silently ignored by the view it is meant to configure.
+      surfaceType: existing.surfaceType,
+      landing: false,
+      generation: existing.generation + 1
+    };
+    reg.flights.set(id, next);
+    const retargeted = statusFor(id);
+    retargeted.settled = false;
+    animate(next, false);
+    publish(reg);
+    return awaitSurfaceMount(id);
+  }
+
+  // Nothing live yet. `from` is the origin rect the caller measured; without one
+  // the surface simply appears at `rect` rather than flying in from a corner.
+  const flight = {
+    id,
+    content,
+    from: options?.from ?? rect,
+    to: rect,
+    cornerRadius: options?.cornerRadius ?? DEFAULT_FLIGHT_CORNER_RADIUS,
+    contentFit: options?.contentFit ?? 'cover',
+    surfaceType: options?.surfaceType ?? 'textureView',
+    progress: makeMutable(0),
+    landing: false,
+    generation: 0
+  };
+  reg.flights.set(id, flight);
+  const status = statusFor(id);
+  status.mounted = false;
+  status.settled = false;
+  status.handedOff = false;
+  animate(flight, false);
+  publish(reg);
+  return awaitSurfaceMount(id);
+}
+
+/**
+ * Resolve once `<MediaFlightLayer>` reports it has committed the surface, or
+ * after {@link SURFACE_MOUNT_TIMEOUT_MS} — which is what happens when no layer
+ * is mounted at all. Degrading to "carry on without a transition" is right;
+ * never resolving would mean an app that forgot one line at its root has a feed
+ * whose videos cannot be opened.
+ */
+function awaitSurfaceMount(id) {
+  const status = statusFor(id);
+  if (status.mounted) return Promise.resolve();
+  return new Promise(resolve => {
+    status.mountWaiters.push(resolve);
+    if (status.mountTimer !== null) return;
+    status.mountTimer = setTimeout(() => {
+      status.mountTimer = null;
+      warnNoLayerMounted();
+      resolveMountWaiters(status);
+    }, SURFACE_MOUNT_TIMEOUT_MS);
+  });
+}
+
+/**
+ * The layer calls this from the surface's mount effect. It is the commit signal
+ * `flyTo` waits on, and the only thing that makes the ordering contract above
+ * true rather than hopeful.
+ */
+export function notifySurfaceMounted(id) {
+  const status = statusFor(id);
+  status.mounted = true;
+  resolveMountWaiters(status);
+}
+
+/** The layer calls this when a leg's animation finishes. */
+export function notifySurfaceSettled(id) {
+  const status = statusFor(id);
+  status.settled = true;
+  if (status.handedOff) releaseFlight(id);
+}
+
+/**
+ * A destination surface reporting that it is LIVE — it has presented a frame of
+ * its own, so the flying copy is now redundant and can go.
+ *
+ * This is the release condition, and it is deliberately not the animation's
+ * clock. Measured against production, a fullscreen video route needs ~1 s from
+ * tap to first presented frame; releasing when a ~300 ms animation ends would
+ * leave ~700 ms with nothing live on screen — the hole the transition exists to
+ * cover, made longer.
+ *
+ * Wire it by giving the destination's `<MediaSurface>` a `flightId`; it calls
+ * this itself on its first frame. A destination that renders something other
+ * than a Bloom surface can call it directly.
+ */
+export function handOffFlight(id) {
+  const reg = registry();
+  if (!reg.flights.has(id)) return;
+  const status = statusFor(id);
+  status.handedOff = true;
+  // Mid-flight the surface is still travelling: releasing now would make it
+  // vanish somewhere between the two rects. `notifySurfaceSettled` picks it up.
+  if (status.settled) releaseFlight(id);
+}
+
+/**
+ * Aim the live surface at its anchor and release it once it lands.
+ *
+ * With no measurable anchor there is nothing to fly to, so the surface is
+ * released immediately — whoever owns the media renders its own copy again at
+ * that point, and holding a flying copy over it would double the video.
+ */
+export function flyBack(id) {
+  const flight = registry().flights.get(id);
+  if (!flight) return;
+  void measureAnchor(id).then(rect => {
+    // Re-read: the flight may have been released or retargeted while the
+    // measurement was outstanding (`measureInWindow` is asynchronous on both
+    // platforms), and landing a stale record would fly the wrong surface.
+    const reg = registry();
+    if (reg.flights.get(id) !== flight) return;
+    if (rect === null) {
+      releaseFlight(id);
+      return;
+    }
+    const landing = {
+      ...flight,
+      from: interpolateRect(flight.from, flight.to, flight.progress.value),
+      to: rect,
+      landing: true,
+      generation: flight.generation + 1
+    };
+    reg.flights.set(id, landing);
+    animate(landing, true);
+    publish(reg);
+  });
+}
+
+/** Drop the surface for `id`. Called when a landing leg settles, and on teardown. */
+export function releaseFlight(id) {
+  const reg = registry();
+  const status = reg.status.get(id);
+  if (status) {
+    // A waiter still parked on `flyTo`'s promise would otherwise hang until its
+    // own timeout, holding a caller that has nothing left to wait for.
+    clearTimers(status);
+    resolveMountWaiters(status);
+    reg.status.delete(id);
+  }
+  if (!reg.flights.delete(id)) return;
+  publish(reg);
+}
+
+/** Test seam — drops every anchor and surface. */
+export function resetMediaFlight() {
+  const existing = globalThis.__oxyhq_bloom_media_flight__;
+  // Timers outlive a registry swap: an unfired mount timeout from the previous
+  // suite would warn — and resolve a waiter nobody is holding — inside the next.
+  if (existing) for (const status of existing.status.values()) clearTimers(status);
+  globalThis.__oxyhq_bloom_media_flight__ = emptyRegistry();
+  hasWarnedNoLayer = false;
+}
+let hasWarnedNoLayer = false;
+
+/**
+ * One warning per module lifetime, and none in production — the same mechanism
+ * as the optional-peer boundaries. A missing `<MediaFlightLayer>` is otherwise
+ * completely silent: every `flyTo` resolves on its timeout and the app simply
+ * never shows a transition, which looks like the feature not being wired rather
+ * than the root not being.
+ */
+function warnNoLayerMounted() {
+  if (process.env.NODE_ENV === 'production' || hasWarnedNoLayer) return;
+  hasWarnedNoLayer = true;
+  // eslint-disable-next-line no-console
+  console.warn('[Bloom] flyTo() timed out waiting for a media surface to mount. Nothing is ' + 'rendering <MediaFlightLayer>, so no media transition will ever run and a ' + 'video opened from a feed will restart. Mount it ONCE at the app root ' + '(app/_layout.tsx), above the router.');
+}
+
+/** Rect at `t` along `from` → `to`, so a retarget resumes rather than snapping. */
+function interpolateRect(from, to, t) {
+  const clamped = t < 0 ? 0 : t > 1 ? 1 : t;
+  return {
+    x: from.x + (to.x - from.x) * clamped,
+    y: from.y + (to.y - from.y) * clamped,
+    width: from.width + (to.width - from.width) * clamped,
+    height: from.height + (to.height - from.height) * clamped
+  };
+}
+
+/**
+ * Run one leg: 0 → 1 on the flight's own value, and on the shared `progress` a
+ * consumer reads.
+ *
+ * Both are driven with the SAME curve rather than one deriving from the other,
+ * because deriving would need a `useAnimatedReaction` — a hook, in a module with
+ * no component to hang it on. Two animations on two shared values cost a few
+ * bytes on the UI thread and keep the driver at the call site.
+ *
+ * The springs and the web timings are the media gallery's, imported rather than
+ * re-tuned: a flight that lands in the gallery and the gallery's own open
+ * transition are the same motion, and two copies of a spring config drift.
+ */
+function animate(flight, landing) {
+  const reg = registry();
+  const id = flight.id;
+  // EVERY leg reports its settlement, because the release condition is now
+  // "settled AND the destination is live" and either can arrive first. A
+  // `finished === false` callback means the leg was interrupted by a retarget,
+  // which owns the surface from then on.
+  //
+  // A LANDING leg is the one case that releases on its own: it has flown back to
+  // its anchor and there is nothing left to cover.
+  const onSettled = finished => {
+    'worklet';
+
+    if (finished === false) return;
+    runOnJS(landing ? releaseFlight : notifySurfaceSettled)(id);
+  };
+  flight.progress.value = 0;
+  reg.progress.value = 0;
+  if (Platform.OS === 'web') {
+    const duration = landing ? CLOSE_DURATION_WEB : OPEN_DURATION_WEB;
+    const easing = landing ? Easing.in(Easing.cubic) : Easing.out(Easing.cubic);
+    flight.progress.value = withTiming(1, {
+      duration,
+      easing
+    }, onSettled);
+    reg.progress.value = withTiming(1, {
+      duration,
+      easing
+    });
+    return;
+  }
+  const spring = landing ? CLOSE_SPRING : OPEN_SPRING;
+  flight.progress.value = withSpring(1, spring, onSettled);
+  reg.progress.value = withSpring(1, spring);
+}
+//# sourceMappingURL=store.js.map