@oxyhq/bloom 1.0.6 → 1.2.0

package/lib/typescript/commonjs/media-flight/expo-video-module.d.ts

@@ -0,0 +1,103 @@
+/**
+ * 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.
+ */
+import type { ComponentType } from 'react';
+import type { StyleProp, ViewStyle } from 'react-native';
+/**
+ * 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.
+ */
+export interface VideoPlayerLike {
+    readonly playing: boolean;
+    play(): void;
+    pause(): void;
+}
+/** How a video is scaled inside its box. Mirrors expo-video's `VideoContentFit`. */
+export type VideoSurfaceContentFit = 'contain' | 'cover' | 'fill';
+/**
+ * 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.
+ */
+export type VideoSurfaceType = 'textureView' | 'surfaceView';
+/** The slice of `VideoViewProps` Bloom passes. */
+export interface VideoViewLikeProps {
+    player?: VideoPlayerLike | null;
+    contentFit?: VideoSurfaceContentFit;
+    surfaceType?: VideoSurfaceType;
+    nativeControls?: boolean;
+    style?: StyleProp<ViewStyle>;
+    pointerEvents?: 'auto' | 'none' | 'box-none' | 'box-only';
+    accessibilityLabel?: string;
+    /**
+     * Raised once the mounted player has rendered its first frame into this view.
+     * On web expo-video raises it from the element's `loadeddata` event; it is the
+     * only OBSERVABLE "this surface is live now" the package offers, and the media
+     * flight layer's hand-off depends on it rather than on a timer.
+     */
+    onFirstFrameRender?: () => void;
+}
+/** The slice of expo-video's module surface Bloom renders. */
+export interface ExpoVideoLike {
+    VideoView: ComponentType<VideoViewLikeProps>;
+}
+/** The expo-video module, or `null` when the optional peer is not installed. */
+export declare function loadExpoVideo(): ExpoVideoLike | null;
+/**
+ * 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 declare function warnExpoVideoUnavailable(): void;
+/** Test seam — drops the cached module handle so a suite can load it again. */
+export declare function resetExpoVideoModule(): void;
+//# sourceMappingURL=expo-video-module.d.ts.map

package/lib/typescript/commonjs/media-flight/expo-video-module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expo-video-module.d.ts","sourceRoot":"","sources":["../../../../src/media-flight/expo-video-module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAC3C,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AASzD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,IAAI,IAAI,IAAI,CAAC;IACb,KAAK,IAAI,IAAI,CAAC;CACf;AAED,oFAAoF;AACpF,MAAM,MAAM,sBAAsB,GAAG,SAAS,GAAG,OAAO,GAAG,MAAM,CAAC;AAElE;;;;;;;;;;GAUG;AACH,MAAM,MAAM,gBAAgB,GAAG,aAAa,GAAG,aAAa,CAAC;AAE7D,kDAAkD;AAClD,MAAM,WAAW,kBAAkB;IACjC,MAAM,CAAC,EAAE,eAAe,GAAG,IAAI,CAAC;IAChC,UAAU,CAAC,EAAE,sBAAsB,CAAC;IACpC,WAAW,CAAC,EAAE,gBAAgB,CAAC;IAC/B,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,KAAK,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;IAC7B,aAAa,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,UAAU,GAAG,UAAU,CAAC;IAC1D,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B;;;;;OAKG;IACH,kBAAkB,CAAC,EAAE,MAAM,IAAI,CAAC;CACjC;AAED,8DAA8D;AAC9D,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,aAAa,CAAC,kBAAkB,CAAC,CAAC;CAC9C;AAQD,gFAAgF;AAChF,wBAAgB,aAAa,IAAI,aAAa,GAAG,IAAI,CAiCpD;AAUD;;;;;GAKG;AACH,wBAAgB,wBAAwB,IAAI,IAAI,CAa/C;AAED,+EAA+E;AAC/E,wBAAgB,oBAAoB,IAAI,IAAI,CAI3C"}

package/lib/typescript/commonjs/media-flight/index.d.ts

@@ -0,0 +1,9 @@
+export { MediaFlightLayer } from './MediaFlightLayer';
+export { MediaSurface, MediaPoster, EmptyMediaSurface } from './MediaSurface';
+export { useMediaFlight } from './use-media-flight';
+export { DEFAULT_FLIGHT_CORNER_RADIUS, flightProgress, handOffFlight, hasFlight, releaseFlight, resetMediaFlight, } from './store';
+export { SURFACE_MOUNT_TIMEOUT_MS } from './constants';
+export { loadExpoVideo, warnExpoVideoUnavailable, resetExpoVideoModule, type ExpoVideoLike, type VideoPlayerLike, type VideoSurfaceContentFit, type VideoSurfaceType, type VideoViewLikeProps, } from './expo-video-module';
+export type { MediaFlight, MediaFlightAnchorNode, MediaFlightController, MediaFlightOptions, MediaSurfaceContent, MediaSurfaceImage, MediaSurfaceVideo, MeasuredRect, } from './types';
+export type { MediaSurfaceProps } from './MediaSurface';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/media-flight/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/media-flight/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAC9E,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EACL,4BAA4B,EAC5B,cAAc,EACd,aAAa,EACb,SAAS,EACT,aAAa,EACb,gBAAgB,GACjB,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAC;AACvD,OAAO,EACL,aAAa,EACb,wBAAwB,EACxB,oBAAoB,EACpB,KAAK,aAAa,EAClB,KAAK,eAAe,EACpB,KAAK,sBAAsB,EAC3B,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,GACxB,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EACV,WAAW,EACX,qBAAqB,EACrB,qBAAqB,EACrB,kBAAkB,EAClB,mBAAmB,EACnB,iBAAiB,EACjB,iBAAiB,EACjB,YAAY,GACb,MAAM,SAAS,CAAC;AACjB,YAAY,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC"}

package/lib/typescript/commonjs/media-flight/store.d.ts

@@ -0,0 +1,132 @@
+import { type SharedValue } from 'react-native-reanimated';
+import type { MediaFlight, MediaFlightAnchorNode, MediaFlightOptions, MediaSurfaceContent, MeasuredRect } from './types';
+/**
+ * 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 declare const DEFAULT_FLIGHT_CORNER_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.
+ */
+interface FlightStatus {
+    /** The layer has committed a surface for this id. */
+    mounted: boolean;
+    /** The current leg's animation has finished. */
+    settled: boolean;
+    /** A destination surface has reported that it is live. */
+    handedOff: boolean;
+    /** Waiters on `flyTo`'s promise, resolved once `mounted` turns true. */
+    mountWaiters: Array<() => void>;
+    mountTimer: ReturnType<typeof setTimeout> | null;
+}
+interface Registry {
+    anchors: Map<string, MediaFlightAnchorNode>;
+    flights: Map<string, MediaFlight>;
+    status: Map<string, FlightStatus>;
+    listeners: Set<() => void>;
+    /**
+     * The array handed to `useSyncExternalStore`. Cached because that hook
+     * compares snapshots by IDENTITY: rebuilding it per call renders the layer
+     * forever (and React throws "getSnapshot should be cached" in development).
+     */
+    snapshot: readonly MediaFlight[];
+    progress: SharedValue<number>;
+}
+declare global {
+    var __oxyhq_bloom_media_flight__: Registry | undefined;
+}
+/** Subscribe to the live-surface set. The layer's `useSyncExternalStore` half. */
+export declare function subscribeToFlights(listener: () => void): () => void;
+/** The live surfaces, oldest first. Stable identity between changes. */
+export declare function getFlights(): readonly MediaFlight[];
+/** The shared progress value of the most recent leg. */
+export declare function flightProgress(): SharedValue<number>;
+/**
+ * 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 declare function registerAnchor(id: string, node: MediaFlightAnchorNode | null): void;
+export declare function measureAnchor(id: string): Promise<MeasuredRect | null>;
+/** Whether a surface is currently live for `id`. */
+export declare function hasFlight(id: string): boolean;
+/**
+ * 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 declare function flyTo(id: string, rect: MeasuredRect, content: MediaSurfaceContent, options?: MediaFlightOptions): Promise<void>;
+/**
+ * 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 declare function notifySurfaceMounted(id: string): void;
+/** The layer calls this when a leg's animation finishes. */
+export declare function notifySurfaceSettled(id: string): void;
+/**
+ * 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 declare function handOffFlight(id: string): void;
+/**
+ * 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 declare function flyBack(id: string): void;
+/** Drop the surface for `id`. Called when a landing leg settles, and on teardown. */
+export declare function releaseFlight(id: string): void;
+/** Test seam — drops every anchor and surface. */
+export declare function resetMediaFlight(): void;
+export {};
+//# sourceMappingURL=store.d.ts.map

package/lib/typescript/commonjs/media-flight/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../../../src/media-flight/store.ts"],"names":[],"mappings":"AA2BA,OAAO,EAML,KAAK,WAAW,EACjB,MAAM,yBAAyB,CAAC;AAUjC,OAAO,KAAK,EACV,WAAW,EACX,qBAAqB,EACrB,kBAAkB,EAClB,mBAAmB,EACnB,YAAY,EACb,MAAM,SAAS,CAAC;AAEjB;;;;GAIG;AACH,eAAO,MAAM,4BAA4B,IAAsB,CAAC;AAEhE;;;;;;;;;GASG;AACH,UAAU,YAAY;IACpB,qDAAqD;IACrD,OAAO,EAAE,OAAO,CAAC;IACjB,gDAAgD;IAChD,OAAO,EAAE,OAAO,CAAC;IACjB,0DAA0D;IAC1D,SAAS,EAAE,OAAO,CAAC;IACnB,wEAAwE;IACxE,YAAY,EAAE,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC;IAChC,UAAU,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,GAAG,IAAI,CAAC;CAClD;AAED,UAAU,QAAQ;IAChB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAAC;IAC5C,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IAClC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IAClC,SAAS,EAAE,GAAG,CAAC,MAAM,IAAI,CAAC,CAAC;IAC3B;;;;OAIG;IACH,QAAQ,EAAE,SAAS,WAAW,EAAE,CAAC;IACjC,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CAC/B;AAED,OAAO,CAAC,MAAM,CAAC;IAEb,IAAI,4BAA4B,EAAE,QAAQ,GAAG,SAAS,CAAC;CACxD;AAsDD,kFAAkF;AAClF,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAMnE;AAED,wEAAwE;AACxE,wBAAgB,UAAU,IAAI,SAAS,WAAW,EAAE,CAEnD;AAED,wDAAwD;AACxD,wBAAgB,cAAc,IAAI,WAAW,CAAC,MAAM,CAAC,CAEpD;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,qBAAqB,GAAG,IAAI,GAAG,IAAI,CAInF;AAED,wBAAgB,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAWtE;AAED,oDAAoD;AACpD,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAE7C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,KAAK,CACnB,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,YAAY,EAClB,OAAO,EAAE,mBAAmB,EAC5B,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,IAAI,CAAC,CA0Df;AAuBD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAIrD;AAED,4DAA4D;AAC5D,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAIrD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAQ9C;AAED;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAyBxC;AAED,qFAAqF;AACrF,wBAAgB,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAY9C;AAED,kDAAkD;AAClD,wBAAgB,gBAAgB,IAAI,IAAI,CAOvC"}

package/lib/typescript/commonjs/media-flight/types.d.ts

@@ -0,0 +1,195 @@
+import type { SharedValue } from 'react-native-reanimated';
+import type { VideoPlayerLike, VideoSurfaceType } from './expo-video-module';
+/**
+ * On-screen rectangle of a media anchor, in WINDOW coordinates (what
+ * `measureInWindow` reports). Bloom-owned so consumers don't depend on an
+ * app-local shape.
+ */
+export interface MeasuredRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/**
+ * Anything that can report its own window rect. This is exactly react-native's
+ * `View` instance shape (and react-native-web's), narrowed to the one method
+ * the flight layer calls — so a consumer passes its host node straight through
+ * without Bloom naming `View` in its public API.
+ */
+export interface MediaFlightAnchorNode {
+    measureInWindow(callback: (x: number, y: number, width: number, height: number) => void): void;
+}
+/** A still image painted into a media surface. */
+export interface MediaSurfaceImage {
+    /**
+     * Present so the union discriminates. Optional on the image arm so an image
+     * literal stays `{ uri }` — the shape every existing gallery caller writes.
+     */
+    kind?: 'image';
+    /** Source URI rendered as the image. */
+    uri: string;
+}
+/**
+ * A video painted into a media surface.
+ *
+ * **Bloom neither creates nor destroys the player.** The consumer owns it (via
+ * expo-video's `useVideoPlayer`, a store, whatever it likes) and hands the same
+ * object to every surface that should show that video. That is the entire
+ * mechanism behind "the video does not restart": expo-video separates the
+ * `VideoPlayer` OBJECT from the `VideoView` that displays it, and one player may
+ * feed several views. Swapping which view is mounted therefore moves the picture
+ * without touching playback — whereas re-creating the player would seek back to
+ * zero and re-open the network stream.
+ */
+export interface MediaSurfaceVideo {
+    kind: 'video';
+    /** The expo-video `VideoPlayer` the CONSUMER created and owns. */
+    player: VideoPlayerLike;
+    /**
+     * Still frame shown behind the video surface. It is what the user sees before
+     * the first video frame renders, and the only thing rendered at all when the
+     * optional `expo-video` peer is absent.
+     */
+    poster?: string;
+}
+/** What a media surface paints: a still image, or a consumer-owned video. */
+export type MediaSurfaceContent = MediaSurfaceImage | MediaSurfaceVideo;
+/**
+ * A media surface currently owned by the flight layer.
+ *
+ * One per id, ever — that is the contract. `flyTo` on an id that is already in
+ * flight RETARGETS this record rather than adding a second surface, which is
+ * what keeps a single `VideoView` alive across the whole transition.
+ */
+export interface MediaFlight {
+    id: string;
+    content: MediaSurfaceContent;
+    /** Rect the current leg starts from. */
+    from: MeasuredRect;
+    /** Rect the current leg ends at. */
+    to: MeasuredRect;
+    cornerRadius: number;
+    contentFit: 'contain' | 'cover';
+    /** See {@link MediaFlightOptions.surfaceType}. Fixed for the surface's life. */
+    surfaceType: VideoSurfaceType;
+    /**
+     * The leg's progress, 0 at `from` and 1 at `to`. Owned by the store (created
+     * with `makeMutable`, not a hook) because the animation is STARTED by an
+     * imperative call and only READ by the layer — an effect in the layer would
+     * have to re-derive from a prop and would fire a frame late.
+     */
+    progress: SharedValue<number>;
+    /**
+     * True once `flyBack` has aimed this surface at its anchor: when the leg
+     * settles, the surface is released instead of parked.
+     */
+    landing: boolean;
+    /** Bumped on every retarget, so React remounts nothing but the layer re-reads. */
+    generation: number;
+}
+/** Options for a single `flyTo` leg. */
+export interface MediaFlightOptions {
+    /**
+     * Rect the surface starts from, used only when nothing is live for the id
+     * yet. This is the origin thumbnail's measured rect — `measureAnchor(id)` is
+     * what produces it. Omitted, the surface appears at its destination instead
+     * of flying in from a corner, which is the right degradation when the origin
+     * could not be measured (virtualised away, already unmounted).
+     *
+     * It is ignored on a retarget: a surface already in flight resumes from where
+     * it currently IS, never from where it once started.
+     */
+    from?: MeasuredRect;
+    /**
+     * Corner radius of the flying box. Defaults to Bloom's `radius-12`, the same
+     * default the media gallery uses for its fitted media.
+     */
+    cornerRadius?: number;
+    /**
+     * How the media fills the flying box. `'cover'` matches a cropped feed
+     * thumbnail; `'contain'` matches a fitted fullscreen view. Defaults to
+     * `'cover'`, because a flight almost always STARTS at a cropped thumbnail.
+     */
+    contentFit?: 'contain' | 'cover';
+    /**
+     * Android's rendering surface for the FLYING video view.
+     *
+     * Defaults to `'textureView'` because a `SurfaceView` is composited by the
+     * system outside the view hierarchy: it ignores its parent's clip, corner
+     * radius and transform, which is every property a flying box depends on.
+     *
+     * **This means a flight crosses a surface-type boundary at hand-off whenever
+     * the destination uses expo-video's own `'surfaceView'` default.** Whether
+     * that boundary is visible is a device question, not a code question, and it
+     * is the reason this is a knob rather than a constant: with it you can fly as
+     * `'surfaceView'` and match a destination that has not changed, or leave it
+     * and change the destination instead. Measure before choosing — the flight
+     * may not flicker at all, in which case the right answer is to do nothing.
+     */
+    surfaceType?: VideoSurfaceType;
+}
+/**
+ * The imperative surface of the flight layer, returned by `useMediaFlight()`.
+ *
+ * Origin and destination only DECLARE where they want the surface; the layer is
+ * what paints it. Neither renders the media itself while a flight is live, so
+ * there is never a second copy to keep in sync.
+ */
+export interface MediaFlightController {
+    /**
+     * Register (or, with `null`, clear) the node that anchors `id` on screen.
+     * Wire it as a callback ref on the host view the media would otherwise
+     * occupy. The most recently registered node for an id is the current anchor,
+     * which is what makes a destination screen mounting over an origin screen
+     * take over as the fly-back target.
+     */
+    registerAnchor: (id: string, node: MediaFlightAnchorNode | null) => void;
+    /**
+     * Measure the current anchor for `id` in window coordinates. Resolves `null`
+     * when no anchor is registered (unmounted / virtualised) or it has no area,
+     * which is the signal to skip the transition rather than fly to nowhere.
+     */
+    measureAnchor: (id: string) => Promise<MeasuredRect | null>;
+    /**
+     * Take the surface for `id` live (if it is not already) and move it to
+     * `rect`. The first call flies in from {@link MediaFlightOptions.from} when
+     * the caller measured an origin, and appears in place when it did not. A call
+     * for an id already in flight RETARGETS the same surface — one surface per
+     * id, always.
+     *
+     * **Await it before tearing the origin down** (on web: before navigating).
+     * The promise resolves once the layer has committed its surface, which is what
+     * puts it in expo-video's mounted set while the origin is still there — the
+     * mechanism that carries `currentTime` across instead of restarting at zero.
+     * It resolves on a short timeout if no layer is mounted, so a missing root
+     * component degrades to "no transition" rather than to a dead feed.
+     */
+    flyTo: (id: string, rect: MeasuredRect, content: MediaSurfaceContent, options?: MediaFlightOptions) => Promise<void>;
+    /**
+     * Fly the live surface for `id` back to its current anchor and release it
+     * once it lands. With no measurable anchor the surface is released at once —
+     * the caller is expected to render its own copy again at that point.
+     */
+    flyBack: (id: string) => void;
+    /**
+     * Tell the layer a destination surface is LIVE, so the flying copy can go.
+     *
+     * Usually you do not call this: give the destination's `<MediaSurface>` a
+     * `flightId` and it reports its own first frame. It is here for a destination
+     * that renders something other than a Bloom surface.
+     *
+     * Called mid-flight it is remembered, not obeyed — the surface finishes
+     * travelling first, or it would vanish between the two rects.
+     */
+    handOff: (id: string) => void;
+    /**
+     * Progress of the most recent leg, 0 → 1. Read it from a worklet to fade an
+     * origin placeholder out and a destination's chrome in, in lockstep with the
+     * flight. Shared by every flight: concurrent flights (which the one-surface-
+     * per-id contract permits across DIFFERENT ids) overwrite each other here,
+     * and each surface's own geometry is driven by its own value regardless.
+     */
+    progress: SharedValue<number>;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/typescript/commonjs/media-flight/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/media-flight/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAE3D,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE7E;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;GAKG;AACH,MAAM,WAAW,qBAAqB;IACpC,eAAe,CACb,QAAQ,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,GACtE,IAAI,CAAC;CACT;AAED,kDAAkD;AAClD,MAAM,WAAW,iBAAiB;IAChC;;;OAGG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,wCAAwC;IACxC,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,OAAO,CAAC;IACd,kEAAkE;IAClE,MAAM,EAAE,eAAe,CAAC;IACxB;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,6EAA6E;AAC7E,MAAM,MAAM,mBAAmB,GAAG,iBAAiB,GAAG,iBAAiB,CAAC;AAExE;;;;;;GAMG;AACH,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,mBAAmB,CAAC;IAC7B,wCAAwC;IACxC,IAAI,EAAE,YAAY,CAAC;IACnB,oCAAoC;IACpC,EAAE,EAAE,YAAY,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,SAAS,GAAG,OAAO,CAAC;IAChC,gFAAgF;IAChF,WAAW,EAAE,gBAAgB,CAAC;IAC9B;;;;;OAKG;IACH,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC9B;;;OAGG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB,kFAAkF;IAClF,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,wCAAwC;AACxC,MAAM,WAAW,kBAAkB;IACjC;;;;;;;;;OASG;IACH,IAAI,CAAC,EAAE,YAAY,CAAC;IACpB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,UAAU,CAAC,EAAE,SAAS,GAAG,OAAO,CAAC;IACjC;;;;;;;;;;;;;;OAcG;IACH,WAAW,CAAC,EAAE,gBAAgB,CAAC;CAChC;AAED;;;;;;GAMG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;;;;OAMG;IACH,cAAc,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,qBAAqB,GAAG,IAAI,KAAK,IAAI,CAAC;IACzE;;;;OAIG;IACH,aAAa,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAAC;IAC5D;;;;;;;;;;;;;OAaG;IACH,KAAK,EAAE,CACL,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,YAAY,EAClB,OAAO,EAAE,mBAAmB,EAC5B,OAAO,CAAC,EAAE,kBAAkB,KACzB,OAAO,CAAC,IAAI,CAAC,CAAC;IACnB;;;;OAIG;IACH,OAAO,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;IAC9B;;;;;;;;;OASG;IACH,OAAO,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;IAC9B;;;;;;OAMG;IACH,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CAC/B"}

package/lib/typescript/commonjs/media-flight/use-media-flight.d.ts

@@ -0,0 +1,4 @@
+import type { MediaFlightController } from './types';
+/** The media-flight controller. Stable for the life of the bundle. */
+export declare function useMediaFlight(): MediaFlightController;
+//# sourceMappingURL=use-media-flight.d.ts.map

package/lib/typescript/commonjs/media-flight/use-media-flight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-media-flight.d.ts","sourceRoot":"","sources":["../../../../src/media-flight/use-media-flight.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAsBrD,sEAAsE;AACtE,wBAAgB,cAAc,IAAI,qBAAqB,CAEtD"}

package/lib/typescript/commonjs/zoomable-media-gallery/ZoomableMediaGallery.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import type { ZoomableMediaGalleryHandle, ZoomableMediaGalleryProps } from './types';
+export declare const ZoomableMediaGallery: React.ForwardRefExoticComponent<ZoomableMediaGalleryProps & React.RefAttributes<ZoomableMediaGalleryHandle>>;
+export default ZoomableMediaGallery;
+//# sourceMappingURL=ZoomableMediaGallery.d.ts.map

package/lib/typescript/commonjs/zoomable-media-gallery/ZoomableMediaGallery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ZoomableMediaGallery.d.ts","sourceRoot":"","sources":["../../../../src/zoomable-media-gallery/ZoomableMediaGallery.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA6E,MAAM,OAAO,CAAC;AAkElG,OAAO,KAAK,EAGV,0BAA0B,EAC1B,yBAAyB,EAC1B,MAAM,SAAS,CAAC;AAkkCjB,eAAO,MAAM,oBAAoB,8GAA4B,CAAC;AAgL9D,eAAe,oBAAoB,CAAC"}

package/lib/typescript/commonjs/{zoomable-image-gallery → zoomable-media-gallery}/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../src/zoomable-image-gallery/constants.ts"],"names":[],"mappings":"AAEA,0EAA0E;AAC1E,eAAO,MAAM,YAAY,MAAM,CAAC;AAChC,oFAAoF;AACpF,eAAO,MAAM,iBAAiB,MAAM,CAAC;AACrC,kFAAkF;AAClF,eAAO,MAAM,mBAAmB,MAAM,CAAC;AACvC,uDAAuD;AACvD,eAAO,MAAM,cAAc,MAAM,CAAC;AAClC,kFAAkF;AAClF,eAAO,MAAM,gBAAgB,OAAO,CAAC;AACrC,0FAA0F;AAC1F,eAAO,MAAM,oBAAoB,KAAK,CAAC;AAEvC,eAAO,MAAM,iBAAiB,MAAM,CAAC;AACrC,eAAO,MAAM,kBAAkB,MAAM,CAAC;AACtC,eAAO,MAAM,gBAAgB,MAAM,CAAC;AAEpC,eAAO,MAAM,WAAW;;;;CAAsD,CAAC;AAC/E,eAAO,MAAM,YAAY;;;;CAAuD,CAAC;AACjF,eAAO,MAAM,gBAAgB;;;;CAAsD,CAAC;AAEpF,+EAA+E;AAC/E,eAAO,MAAM,qBAAqB,IAAsB,CAAC;AAEzD,yEAAyE;AACzE,eAAO,MAAM,cAAc,IAAI,CAAC;AAChC,oDAAoD;AACpD,eAAO,MAAM,cAAc,IAAI,CAAC;AAChC,qFAAqF;AACrF,eAAO,MAAM,mBAAmB,MAAM,CAAC;AACvC,mFAAmF;AACnF,eAAO,MAAM,qBAAqB,IAAI,CAAC;AACvC,sEAAsE;AACtE,eAAO,MAAM,gBAAgB,MAAM,CAAC;AACpC,qFAAqF;AACrF,eAAO,MAAM,iBAAiB,MAAM,CAAC;AACrC,2EAA2E;AAC3E,eAAO,MAAM,yBAAyB,KAAK,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../src/zoomable-media-gallery/constants.ts"],"names":[],"mappings":"AAEA,0EAA0E;AAC1E,eAAO,MAAM,YAAY,MAAM,CAAC;AAChC,oFAAoF;AACpF,eAAO,MAAM,iBAAiB,MAAM,CAAC;AACrC,kFAAkF;AAClF,eAAO,MAAM,mBAAmB,MAAM,CAAC;AACvC,uDAAuD;AACvD,eAAO,MAAM,cAAc,MAAM,CAAC;AAClC,kFAAkF;AAClF,eAAO,MAAM,gBAAgB,OAAO,CAAC;AACrC,0FAA0F;AAC1F,eAAO,MAAM,oBAAoB,KAAK,CAAC;AAEvC,eAAO,MAAM,iBAAiB,MAAM,CAAC;AACrC,eAAO,MAAM,kBAAkB,MAAM,CAAC;AACtC,eAAO,MAAM,gBAAgB,MAAM,CAAC;AAEpC,eAAO,MAAM,WAAW;;;;CAAsD,CAAC;AAC/E,eAAO,MAAM,YAAY;;;;CAAuD,CAAC;AACjF,eAAO,MAAM,gBAAgB;;;;CAAsD,CAAC;AAEpF,+EAA+E;AAC/E,eAAO,MAAM,qBAAqB,IAAsB,CAAC;AAEzD,yEAAyE;AACzE,eAAO,MAAM,cAAc,IAAI,CAAC;AAChC,oDAAoD;AACpD,eAAO,MAAM,cAAc,IAAI,CAAC;AAChC,qFAAqF;AACrF,eAAO,MAAM,mBAAmB,MAAM,CAAC;AACvC,mFAAmF;AACnF,eAAO,MAAM,qBAAqB,IAAI,CAAC;AACvC,sEAAsE;AACtE,eAAO,MAAM,gBAAgB,MAAM,CAAC;AACpC,qFAAqF;AACrF,eAAO,MAAM,iBAAiB,MAAM,CAAC;AACrC,2EAA2E;AAC3E,eAAO,MAAM,yBAAyB,KAAK,CAAC"}

package/lib/typescript/commonjs/zoomable-media-gallery/index.d.ts

@@ -0,0 +1,4 @@
+export { ZoomableMediaGallery, ZoomableMediaGallery as default } from './ZoomableMediaGallery';
+export type { ZoomableMediaGalleryHandle, ZoomableMediaGalleryProps, GalleryImage, GalleryVideo, GalleryMedia, MeasureThumb, MeasuredRect, } from './types';
+export * from './constants';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/{zoomable-image-gallery → zoomable-media-gallery}/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/zoomable-image-gallery/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,oBAAoB,IAAI,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAC/F,YAAY,EACV,0BAA0B,EAC1B,yBAAyB,EACzB,YAAY,EACZ,YAAY,EACZ,YAAY,GACb,MAAM,SAAS,CAAC;AACjB,cAAc,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/zoomable-media-gallery/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,oBAAoB,IAAI,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAC/F,YAAY,EACV,0BAA0B,EAC1B,yBAAyB,EACzB,YAAY,EACZ,YAAY,EACZ,YAAY,EACZ,YAAY,EACZ,YAAY,GACb,MAAM,SAAS,CAAC;AACjB,cAAc,aAAa,CAAC"}

package/lib/typescript/commonjs/zoomable-media-gallery/types.d.ts

@@ -0,0 +1,90 @@
+import type { MeasuredRect, MediaSurfaceImage, MediaSurfaceVideo } from '../media-flight/types';
+/**
+ * A still image page.
+ *
+ * `kind` is optional on this arm so an image literal stays `{ uri }` — the shape
+ * every caller already writes, and the reason adding video to this gallery is
+ * not a breaking change for image consumers.
+ */
+export interface GalleryImage extends MediaSurfaceImage {
+    /**
+     * Author-authored accessibility description (Bluesky-style "ALT"). When present,
+     * shown as a caption at the bottom of the fullscreen viewer for the active item.
+     */
+    alt?: string;
+    /**
+     * Optional intrinsic aspect ratio (width / height) supplied by the consumer.
+     * When known ahead of time it avoids a first-frame `Image.getSize` round-trip.
+     */
+    aspectRatio?: number;
+}
+/**
+ * A video page, fed by a `VideoPlayer` the CONSUMER created and owns.
+ *
+ * Bloom neither creates nor destroys players — see `MediaSurfaceVideo`. That is
+ * what lets the same video keep playing as it moves from a feed thumbnail into
+ * this gallery and back out again: one player, a different view.
+ */
+export interface GalleryVideo extends MediaSurfaceVideo {
+    /**
+     * Stable identity for this video. Used as the React key (a video has no `uri`
+     * to key on) and as the media-flight id when the consumer flies it in.
+     */
+    id: string;
+    /** See {@link GalleryImage.alt}. */
+    alt?: string;
+    /**
+     * Intrinsic aspect ratio. Strongly recommended for video: unlike an image
+     * there is nothing to probe for it, so without one the page opens at the
+     * gallery's default ratio and resizes when the first frame arrives.
+     */
+    aspectRatio?: number;
+    /**
+     * URL handed to the share sheet. The poster is not what a user means by
+     * "share this video", so the two are separate; with neither, the share button
+     * is inert for that page.
+     */
+    shareUrl?: string;
+}
+/** One page of the gallery: a still image, or a consumer-owned video. */
+export type GalleryMedia = GalleryImage | GalleryVideo;
+export type { MeasuredRect };
+/**
+ * Resolve the on-screen rect of the thumbnail at `index` within the SAME
+ * media subset the gallery opens/pages in, so the close animation can fly
+ * back to the item currently being viewed. Resolves `null` when the thumbnail
+ * ref is missing (unmounted/virtualized), in which case the gallery falls back
+ * to a plain center fade-out.
+ */
+export type MeasureThumb = (index: number) => Promise<MeasuredRect | null>;
+export interface ZoomableMediaGalleryHandle {
+    /**
+     * Open the gallery at `index` within `items`, animating the zoom from the
+     * tapped thumbnail's measured screen rect (when provided).
+     */
+    open: (items: GalleryMedia[], index: number, rect?: MeasuredRect) => void;
+}
+export interface ZoomableMediaGalleryProps {
+    /** Measures any thumbnail by its media subset index, used on dismiss. */
+    measureThumb?: MeasureThumb;
+    /**
+     * Corner radius applied to the zoomed media. `'circle'` rounds each item to
+     * a full circle at whatever size it is fitted to — what an avatar needs, and
+     * the reason avatars don't need their own viewer.
+     */
+    cornerRadius?: number | 'circle';
+    /**
+     * Bottom page indicator for multi-item galleries. `'dots'` (default) renders the
+     * compact dot row; `'thumbnails'` renders a horizontal strip of tappable media
+     * tiles. The counter pill shows in both. Ignored for single-item galleries.
+     */
+    indicatorVariant?: 'dots' | 'thumbnails';
+    /**
+     * Whether video pages show expo-video's own transport controls. Off by
+     * default, so a video opens as a picture that happens to move — the same
+     * gesture vocabulary (tap to dismiss, drag to dismiss) as an image. Turn it
+     * on for a viewer whose job is watching rather than glancing.
+     */
+    videoControls?: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/typescript/commonjs/zoomable-media-gallery/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/zoomable-media-gallery/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,YAAY,EACZ,iBAAiB,EACjB,iBAAiB,EAClB,MAAM,uBAAuB,CAAC;AAE/B;;;;;;GAMG;AACH,MAAM,WAAW,YAAa,SAAQ,iBAAiB;IACrD;;;OAGG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,YAAa,SAAQ,iBAAiB;IACrD;;;OAGG;IACH,EAAE,EAAE,MAAM,CAAC;IACX,oCAAoC;IACpC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,yEAAyE;AACzE,MAAM,MAAM,YAAY,GAAG,YAAY,GAAG,YAAY,CAAC;AAEvD,YAAY,EAAE,YAAY,EAAE,CAAC;AAE7B;;;;;;GAMG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAAC;AAE3E,MAAM,WAAW,0BAA0B;IACzC;;;OAGG;IACH,IAAI,EAAE,CAAC,KAAK,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,YAAY,KAAK,IAAI,CAAC;CAC3E;AAED,MAAM,WAAW,yBAAyB;IACxC,yEAAyE;IACzE,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,GAAG,QAAQ,CAAC;IACjC;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,MAAM,GAAG,YAAY,CAAC;IACzC;;;;;OAKG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB"}

package/lib/typescript/module/floating/index.d.ts

@@ -3,6 +3,11 @@
  * `select` sit on: one trigger slot, one panel, one row vocabulary, one anchor
  * measurement, instead of five copies.
  *
+ * `level-picker` is the sixth, and it takes only the ROW half — `MenuRowShell`
+ * and the chevron slot for its disclosure row, plus the motion constants — so
+ * the row that reveals a menu's details region cannot disagree with the rows it
+ * reveals about an inset, a highlight or a height.
+ *
  * INTERNAL. This barrel is the family's surface to the five families INSIDE
  * Bloom that build on it — it is deliberately absent from `package.json#exports`
  * and from `src/index.ts`, and `family-layout.test.ts` records that in

package/lib/typescript/module/floating/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/floating/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EACL,eAAe,EACf,mBAAmB,EACnB,oBAAoB,EACpB,oBAAoB,GACrB,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,mBAAmB,EACnB,cAAc,EACd,sBAAsB,EACtB,iBAAiB,EACjB,eAAe,EACf,UAAU,GACX,MAAM,WAAW,CAAC;AACnB,YAAY,EACV,uBAAuB,EACvB,0BAA0B,EAC1B,mBAAmB,GACpB,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAK7C,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,YAAY,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACtD,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,YAAY,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC/D,mBAAmB,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/floating/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,EACL,eAAe,EACf,mBAAmB,EACnB,oBAAoB,EACpB,oBAAoB,GACrB,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,mBAAmB,EACnB,cAAc,EACd,sBAAsB,EACtB,iBAAiB,EACjB,eAAe,EACf,UAAU,GACX,MAAM,WAAW,CAAC;AACnB,YAAY,EACV,uBAAuB,EACvB,0BAA0B,EAC1B,mBAAmB,GACpB,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAK7C,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,YAAY,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACtD,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,YAAY,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC/D,mBAAmB,SAAS,CAAC"}

package/lib/typescript/module/index.d.ts

@@ -77,6 +77,8 @@ export { InputGroup, InputGroupAddon } from './input-group';
 export type { InputGroupProps, InputGroupAddonProps } from './input-group';
 export { Slider } from './slider';
 export type { SliderProps } from './slider';
+export { LevelPicker } from './level-picker';
+export type { LevelPickerProps } from './level-picker';
 export { Combobox } from './combobox';
 export type { ComboboxProps, ComboboxOption } from './combobox';
 export { BottomSheet } from './bottom-sheet';