@swiftbrowser/react 0.28.0 → 0.28.1

package/dist/index.js

@@ -221,6 +221,7 @@ class HostTree {
     };
     const visit = (child, sink, owner, ctx, hoistedTo) => {
       if (child.hidden) return;
+      if (child.kind === PREF_KIND || child.kind === HOIST_KIND) child.stale = false;
       if (child.kind === PREF_KIND) {
         contribute({ kind: "pref", target: child.target, props: child.props }, ctx);
         return;
@@ -4036,7 +4037,7 @@ function protocolRuns(text) {
 }
 function useAudioRecorder(options = {}) {
   const interval = options.meterInterval ?? 50;
-  const host = browserEnvironment.audioRecorder;
+  const host2 = browserEnvironment.audioRecorder;
   const [status, setStatus] = useState("idle");
   const [time, setTime] = useState(0);
   const [levels, setLevels] = useState([]);
@@ -4045,13 +4046,13 @@ function useAudioRecorder(options = {}) {
   statusRef.current = status;
   const fail = (reason) => setError(reason instanceof Error ? reason.message : String(reason));
   useEffect(() => {
-    if (status !== "recording" || !host) return;
+    if (status !== "recording" || !host2) return;
     let reading = false;
     let live = true;
     const timer = setInterval(() => {
       if (reading) return;
       reading = true;
-      host.meter().then((meter) => {
+      host2.meter().then((meter) => {
         if (!live) return;
         setTime(meter.time);
         setLevels((previous) => [...previous, meter.level]);
@@ -4063,15 +4064,15 @@ function useAudioRecorder(options = {}) {
       live = false;
       clearInterval(timer);
     };
-  }, [status, host, interval]);
+  }, [status, host2, interval]);
   useEffect(
     () => () => {
-      if (statusRef.current !== "idle") void host?.cancel().catch(() => void 0);
+      if (statusRef.current !== "idle") void host2?.cancel().catch(() => void 0);
     },
-    [host]
+    [host2]
   );
   const record = useCallback(async () => {
-    if (!host) {
+    if (!host2) {
       setError("unsupported: this page cannot record");
       return;
     }
@@ -4081,28 +4082,28 @@ function useAudioRecorder(options = {}) {
     setLevels([]);
     setStatus("starting");
     try {
-      await host.start();
+      await host2.start();
       setStatus("recording");
     } catch (reason) {
       fail(reason);
       setStatus("idle");
     }
-  }, [host]);
+  }, [host2]);
   const pause = useCallback(async () => {
-    if (!host || statusRef.current !== "recording") return;
-    await host.pause().catch(fail);
+    if (!host2 || statusRef.current !== "recording") return;
+    await host2.pause().catch(fail);
     setStatus("paused");
-  }, [host]);
+  }, [host2]);
   const resume = useCallback(async () => {
-    if (!host || statusRef.current !== "paused") return;
-    await host.resume().catch(fail);
+    if (!host2 || statusRef.current !== "paused") return;
+    await host2.resume().catch(fail);
     setStatus("recording");
-  }, [host]);
+  }, [host2]);
   const stop = useCallback(async () => {
-    if (!host || statusRef.current !== "recording" && statusRef.current !== "paused") return null;
+    if (!host2 || statusRef.current !== "recording" && statusRef.current !== "paused") return null;
     setStatus("stopping");
     try {
-      const recording = await host.stop();
+      const recording = await host2.stop();
       setTime(recording.duration);
       return recording;
     } catch (reason) {
@@ -4111,30 +4112,538 @@ function useAudioRecorder(options = {}) {
     } finally {
       setStatus("idle");
     }
-  }, [host]);
+  }, [host2]);
   const cancel = useCallback(async () => {
-    if (!host || statusRef.current === "idle") return;
-    await host.cancel().catch(fail);
+    if (!host2 || statusRef.current === "idle") return;
+    await host2.cancel().catch(fail);
     setStatus("idle");
     setTime(0);
     setLevels([]);
-  }, [host]);
+  }, [host2]);
   const discard = useCallback(async (url) => {
-    await host?.discard(url).catch(fail);
-  }, [host]);
+    await host2?.discard(url).catch(fail);
+  }, [host2]);
   const trim = useCallback(
     async (url, keep) => {
-      if (!host) throw new Error("unsupported: this page cannot cut audio");
+      if (!host2) throw new Error("unsupported: this page cannot cut audio");
       try {
-        return await host.trim(url, keep);
+        return await host2.trim(url, keep);
       } catch (reason) {
         fail(reason);
         throw reason;
       }
     },
-    [host]
+    [host2]
+  );
+  return { available: host2 !== void 0, status, time, levels, error, record, pause, resume, stop, cancel, discard, trim };
+}
+function host() {
+  const found = browserEnvironment.avAsset;
+  if (!found) throw new Error("unsupported: this page cannot read or write video");
+  return found;
+}
+class CMTime {
+  constructor(value, timescale) {
+    this.value = value;
+    this.timescale = timescale;
+  }
+  value;
+  timescale;
+  static zero = new CMTime(0, 1);
+  static invalid = new CMTime(0, 0);
+  static positiveInfinity = new CMTime(Infinity, 1);
+  /** `CMTime(value:timescale:)`. */
+  static make(value, timescale) {
+    return new CMTime(value, timescale);
+  }
+  /** `CMTime(seconds:preferredTimescale:)`: rounded to the timescale. */
+  static seconds(seconds, preferredTimescale = 600) {
+    if (!Number.isFinite(seconds)) return seconds > 0 ? CMTime.positiveInfinity : CMTime.invalid;
+    return new CMTime(Math.round(seconds * preferredTimescale), preferredTimescale);
+  }
+  get isValid() {
+    return this.timescale > 0;
+  }
+  /** `CMTimeGetSeconds`. */
+  get seconds() {
+    return this.timescale > 0 ? this.value / this.timescale : Number.NaN;
+  }
+  add(other) {
+    return CMTime.seconds(this.seconds + other.seconds, Math.max(this.timescale, other.timescale, 1));
+  }
+  subtract(other) {
+    return CMTime.seconds(this.seconds - other.seconds, Math.max(this.timescale, other.timescale, 1));
+  }
+  /** `CMTimeCompare`: -1, 0 or 1. */
+  compare(other) {
+    const a = this.seconds;
+    const b = other.seconds;
+    return a < b ? -1 : a > b ? 1 : 0;
+  }
+  static minimum(a, b) {
+    return a.compare(b) <= 0 ? a : b;
+  }
+  static maximum(a, b) {
+    return a.compare(b) >= 0 ? a : b;
+  }
+}
+class CMTimeRange {
+  constructor(start, duration) {
+    this.start = start;
+    this.duration = duration;
+  }
+  start;
+  duration;
+  static zero = new CMTimeRange(CMTime.zero, CMTime.zero);
+  /** `CMTimeRange(start:end:)`. */
+  static fromTo(start, end) {
+    return new CMTimeRange(start, CMTime.maximum(end.subtract(start), CMTime.zero));
+  }
+  /** `CMTimeRange(start:duration:)` in seconds. */
+  static seconds(start, duration, preferredTimescale = 600) {
+    return new CMTimeRange(CMTime.seconds(start, preferredTimescale), CMTime.seconds(duration, preferredTimescale));
+  }
+  get end() {
+    return this.start.add(this.duration);
+  }
+  get isEmpty() {
+    return this.duration.seconds <= 0;
+  }
+  containsTime(time) {
+    return time.compare(this.start) >= 0 && time.compare(this.end) < 0;
+  }
+}
+const AVMediaType = { video: "vide", audio: "soun" };
+class AVAssetTrack {
+  constructor(trackID, mediaType, naturalSize, nominalFrameRate, timeRange, codec) {
+    this.trackID = trackID;
+    this.mediaType = mediaType;
+    this.naturalSize = naturalSize;
+    this.nominalFrameRate = nominalFrameRate;
+    this.timeRange = timeRange;
+    this.codec = codec;
+  }
+  trackID;
+  mediaType;
+  naturalSize;
+  nominalFrameRate;
+  timeRange;
+  codec;
+}
+class AVAsset {
+  /** @internal */
+  segmentsForExport() {
+    return this.segments();
+  }
+  /** `loadTracks(withMediaType:)`. */
+  async loadTracks(mediaType) {
+    return (await this.load("tracks")).filter((track) => track.mediaType === mediaType);
+  }
+}
+const tracksOf = (info) => info.tracks.map(
+  (t) => new AVAssetTrack(
+    t.trackID,
+    t.mediaType === "video" ? AVMediaType.video : AVMediaType.audio,
+    t.naturalSize,
+    t.nominalFrameRate,
+    CMTimeRange.seconds(t.timeRange.start, t.timeRange.duration),
+    t.codec
+  )
+);
+class AVURLAsset extends AVAsset {
+  constructor(url) {
+    super();
+    this.url = url;
+  }
+  url;
+  info = null;
+  loaded() {
+    if (!this.info) {
+      this.info = host().load(this.url);
+      this.info.catch(() => {
+        this.info = null;
+      });
+    }
+    return this.info;
+  }
+  async segments() {
+    return [{ url: this.url, start: 0, end: (await this.loaded()).duration }];
+  }
+  async load(key) {
+    const info = await this.loaded();
+    const values = {
+      duration: CMTime.seconds(info.duration),
+      tracks: tracksOf(info),
+      naturalSize: info.naturalSize,
+      isPlayable: info.tracks.length > 0,
+      isExportable: info.tracks.length > 0
+    };
+    return values[key];
+  }
+}
+class AVMutableComposition extends AVAsset {
+  parts = [];
+  /** The composition's length. */
+  get duration() {
+    return CMTime.seconds(this.parts.reduce((sum, part) => sum + part.range.duration.seconds, 0));
+  }
+  /** `insertTimeRange(_:of:at:)`: `range` of `asset` (an `AVURLAsset`, or another composition's parts) placed at `at`. */
+  async insertTimeRange(range, asset, at) {
+    const inserted = [];
+    if (asset instanceof AVURLAsset) {
+      const length = (await asset.load("duration")).seconds;
+      const start = Math.max(0, range.start.seconds);
+      const end = Math.min(length, range.end.seconds);
+      if (end - start > 1e-3) inserted.push({ asset, range: CMTimeRange.seconds(start, end - start) });
+    } else if (asset instanceof AVMutableComposition) {
+      inserted.push(...asset.partsIn(range.start.seconds, range.end.seconds));
+    } else {
+      throw new Error("unsupported: only an AVURLAsset or an AVMutableComposition can be inserted");
+    }
+    const time = Math.max(0, Math.min(at.seconds, this.duration.seconds));
+    const [before, after] = this.splitAt(time);
+    this.parts = [...before, ...inserted, ...after];
+  }
+  /** `removeTimeRange(_:)`: the media in `range` cut out, the rest closing up. */
+  removeTimeRange(range) {
+    const [before] = this.splitAt(range.start.seconds);
+    const [, after] = this.splitAt(range.end.seconds);
+    this.parts = [...before, ...after];
+  }
+  /** The parts' media from `start` to `end` of the composition's timeline. */
+  partsIn(start, end) {
+    const [, from] = this.splitAt(start);
+    const out = [];
+    let cursor = start;
+    for (const part of from) {
+      if (cursor >= end) break;
+      const take = Math.min(part.range.duration.seconds, end - cursor);
+      if (take > 1e-3) out.push({ asset: part.asset, range: CMTimeRange.seconds(part.range.start.seconds, take) });
+      cursor += take;
+    }
+    return out;
+  }
+  /** The parts before `time` and from it, a part across it split in two. */
+  splitAt(time) {
+    const before = [];
+    const after = [];
+    let cursor = 0;
+    for (const part of this.parts) {
+      const length = part.range.duration.seconds;
+      const start = part.range.start.seconds;
+      if (cursor + length <= time + 1e-9) before.push(part);
+      else if (cursor >= time - 1e-9) after.push(part);
+      else {
+        const head = time - cursor;
+        before.push({ asset: part.asset, range: CMTimeRange.seconds(start, head) });
+        after.push({ asset: part.asset, range: CMTimeRange.seconds(start + head, length - head) });
+      }
+      cursor += length;
+    }
+    return [before, after];
+  }
+  async segments() {
+    return this.parts.map((part) => ({ url: part.asset.url, start: part.range.start.seconds, end: part.range.end.seconds }));
+  }
+  async load(key) {
+    const first = this.parts[0]?.asset;
+    const tracks = first ? await first.load("tracks") : [];
+    const values = {
+      duration: this.duration,
+      tracks: tracks.map((t) => new AVAssetTrack(t.trackID, t.mediaType, t.naturalSize, t.nominalFrameRate, new CMTimeRange(CMTime.zero, this.duration), t.codec)),
+      naturalSize: first ? await first.load("naturalSize") : { width: 0, height: 0 },
+      isPlayable: this.parts.length > 0,
+      isExportable: this.parts.length > 0
+    };
+    return values[key];
+  }
+}
+class AVAssetImageGenerator {
+  constructor(asset) {
+    this.asset = asset;
+  }
+  asset;
+  maximumSize = { width: 0, height: 0 };
+  /** Stills come upright (the track's rotation applied), as with `appliesPreferredTrackTransform = true`. */
+  appliesPreferredTrackTransform = true;
+  made = [];
+  /** The file and the time in it that `time` on the asset's timeline falls on (a composition's part). */
+  async source(time) {
+    let cursor = 0;
+    const segments = await this.asset.segmentsForExport();
+    for (const segment of segments) {
+      const length = segment.end - segment.start;
+      if (time < cursor + length || segment === segments[segments.length - 1]) return { url: segment.url, time: segment.start + Math.max(0, Math.min(length, time - cursor)) };
+      cursor += length;
+    }
+    throw new Error("empty: the asset has no media");
+  }
+  /** `image(at:)`: the still at `time`. */
+  async image(at) {
+    const { url, time } = await this.source(Math.max(0, at.seconds));
+    const options = {
+      ...this.maximumSize.width > 0 ? { maxWidth: this.maximumSize.width } : {},
+      ...this.maximumSize.height > 0 ? { maxHeight: this.maximumSize.height } : {}
+    };
+    const still = await host().image(url, time, options);
+    this.made.push(still.url);
+    return { image: still.url, actualTime: CMTime.seconds(at.seconds + (still.actualTime - time)), width: still.width, height: still.height };
+  }
+  /** `images(for:)`: a still for each time, in turn. */
+  async *images(times) {
+    for (const time of times) yield { ...await this.image(time), requestedTime: time };
+  }
+  /** Lets go of the stills this generator made (their `blob:` URLs on a page). */
+  async release() {
+    const urls = this.made.splice(0);
+    await Promise.all(urls.map((url) => host().release(url)));
+  }
+}
+const AVFileType = { mp4: "public.mpeg-4", mov: "com.apple.quicktime-movie", m4v: "com.apple.m4v-video", webm: "org.webmproject.webm" };
+const FILE_TYPES = {
+  "public.mpeg-4": "mp4",
+  "com.apple.m4v-video": "mp4",
+  "com.apple.quicktime-movie": "mov",
+  "org.webmproject.webm": "webm"
+};
+const AVAssetExportPresetPassthrough = "AVAssetExportPresetPassthrough";
+const AVAssetExportPresetHighestQuality = "AVAssetExportPresetHighestQuality";
+const AVAssetExportPresetMediumQuality = "AVAssetExportPresetMediumQuality";
+const AVAssetExportPresetLowQuality = "AVAssetExportPresetLowQuality";
+const AVAssetExportPreset640x480 = "AVAssetExportPreset640x480";
+const AVAssetExportPreset960x540 = "AVAssetExportPreset960x540";
+const AVAssetExportPreset1280x720 = "AVAssetExportPreset1280x720";
+const AVAssetExportPreset1920x1080 = "AVAssetExportPreset1920x1080";
+const AVAssetExportPreset3840x2160 = "AVAssetExportPreset3840x2160";
+let exports$1 = 0;
+class AVAssetExportSession {
+  constructor(asset, presetName) {
+    this.asset = asset;
+    this.presetName = presetName;
+  }
+  asset;
+  presetName;
+  outputURL = null;
+  outputFileType = AVFileType.mp4;
+  timeRange = null;
+  status = "unknown";
+  progress = 0;
+  error = null;
+  /** Heard as `progress` changes (a few times a second). */
+  onProgress = null;
+  /** The written file's length and MIME type, once completed. */
+  result = null;
+  id = `export-${++exports$1}`;
+  /** `AVAssetExportSession.allExportPresets()`. */
+  static allExportPresets() {
+    return [
+      AVAssetExportPresetPassthrough,
+      AVAssetExportPresetHighestQuality,
+      AVAssetExportPresetMediumQuality,
+      AVAssetExportPresetLowQuality,
+      AVAssetExportPreset640x480,
+      AVAssetExportPreset960x540,
+      AVAssetExportPreset1280x720,
+      AVAssetExportPreset1920x1080,
+      AVAssetExportPreset3840x2160
+    ];
+  }
+  /** The asset's parts, cut to `timeRange` when it is set. */
+  async parts() {
+    const all = await this.asset.segmentsForExport();
+    if (!this.timeRange) return all;
+    const from = this.timeRange.start.seconds;
+    const to = this.timeRange.end.seconds;
+    const out = [];
+    let cursor = 0;
+    for (const segment of all) {
+      const length = segment.end - segment.start;
+      const start = Math.max(from, cursor);
+      const end = Math.min(to, cursor + length);
+      if (end - start > 1e-3) out.push({ url: segment.url, start: segment.start + (start - cursor), end: segment.start + (end - cursor) });
+      cursor += length;
+    }
+    return out;
+  }
+  /** `export()`: writes the file and answers its URL (also `outputURL`); rejects with why it could not. */
+  async export() {
+    if (this.status === "exporting") throw new Error("busy: already exporting");
+    this.status = "exporting";
+    this.error = null;
+    this.setProgress(0);
+    const assets = host();
+    const ticker = setInterval(() => {
+      void assets.progress(this.id).then((p) => this.status === "exporting" && this.setProgress(p));
+    }, 200);
+    try {
+      const result = await assets.export(this.id, {
+        segments: await this.parts(),
+        preset: this.presetName,
+        fileType: FILE_TYPES[this.outputFileType] ?? "mp4",
+        ...this.outputURL ? { outputURL: this.outputURL } : {}
+      });
+      this.outputURL = result.url;
+      this.result = { duration: result.duration, type: result.type };
+      this.status = "completed";
+      this.setProgress(1);
+      return result.url;
+    } catch (reason) {
+      const error = reason instanceof Error ? reason : new Error(String(reason));
+      this.error = error;
+      this.status = error.message.startsWith("cancelled") ? "cancelled" : "failed";
+      throw error;
+    } finally {
+      clearInterval(ticker);
+    }
+  }
+  /** `cancelExport()`. */
+  cancelExport() {
+    if (this.status !== "exporting") return;
+    void host().cancel(this.id);
+  }
+  setProgress(progress) {
+    if (progress === this.progress) return;
+    this.progress = progress;
+    this.onProgress?.(progress);
+  }
+}
+function useVideoRecorder(options = {}) {
+  const interval = options.timeInterval ?? 100;
+  const host2 = browserEnvironment.videoRecorder;
+  const [status, setStatus] = useState("closed");
+  const [stream, setStream] = useState(null);
+  const [facing, setFacing] = useState("user");
+  const [time, setTime] = useState(0);
+  const [error, setError] = useState(null);
+  const statusRef = useRef(status);
+  statusRef.current = status;
+  const facingRef = useRef(facing);
+  facingRef.current = facing;
+  const fail = (reason) => setError(reason instanceof Error ? reason.message : String(reason));
+  useEffect(() => {
+    if (status !== "recording" || !host2) return;
+    let reading = false;
+    let live = true;
+    const timer = setInterval(() => {
+      if (reading) return;
+      reading = true;
+      host2.time().then((seconds) => live && setTime(seconds)).catch(() => void 0).finally(() => {
+        reading = false;
+      });
+    }, interval);
+    return () => {
+      live = false;
+      clearInterval(timer);
+    };
+  }, [status, host2, interval]);
+  useEffect(
+    () => () => {
+      if (statusRef.current !== "closed") void host2?.close().catch(() => void 0);
+    },
+    [host2]
+  );
+  const open = useCallback(
+    async (wanted) => {
+      if (!host2) {
+        setError("unsupported: this page cannot record video");
+        return;
+      }
+      if (statusRef.current === "recording" || statusRef.current === "paused" || statusRef.current === "stopping") return;
+      setError(null);
+      setStatus("opening");
+      try {
+        const opened = await host2.open({ facing: wanted ?? facingRef.current });
+        setStream(opened.stream);
+        setFacing(opened.facing);
+        setStatus("ready");
+      } catch (reason) {
+        fail(reason);
+        setStream(null);
+        setStatus("closed");
+      }
+    },
+    [host2]
+  );
+  const close = useCallback(async () => {
+    if (!host2) return;
+    await host2.close().catch(fail);
+    setStream(null);
+    setStatus("closed");
+    setTime(0);
+  }, [host2]);
+  const flip = useCallback(async () => {
+    if (statusRef.current !== "ready") return;
+    await open(facingRef.current === "user" ? "environment" : "user");
+  }, [open]);
+  const record = useCallback(async () => {
+    if (!host2 || statusRef.current !== "ready") return;
+    setError(null);
+    setTime(0);
+    try {
+      await host2.start();
+      setStatus("recording");
+    } catch (reason) {
+      fail(reason);
+    }
+  }, [host2]);
+  const pause = useCallback(async () => {
+    if (!host2 || statusRef.current !== "recording") return;
+    await host2.pause().catch(fail);
+    setStatus("paused");
+  }, [host2]);
+  const resume = useCallback(async () => {
+    if (!host2 || statusRef.current !== "paused") return;
+    await host2.resume().catch(fail);
+    setStatus("recording");
+  }, [host2]);
+  const stop = useCallback(async () => {
+    if (!host2 || statusRef.current !== "recording" && statusRef.current !== "paused") return null;
+    setStatus("stopping");
+    try {
+      const recording = await host2.stop();
+      setTime(recording.duration);
+      return recording;
+    } catch (reason) {
+      fail(reason);
+      return null;
+    } finally {
+      setStatus("ready");
+    }
+  }, [host2]);
+  const cancel = useCallback(async () => {
+    if (!host2 || statusRef.current !== "recording" && statusRef.current !== "paused") return;
+    await host2.cancel().catch(fail);
+    setStatus("ready");
+    setTime(0);
+  }, [host2]);
+  const discard = useCallback(
+    async (url) => {
+      await host2?.discard(url).catch(fail);
+    },
+    [host2]
+  );
+  return { available: host2 !== void 0, status, stream, facing, time, error, open, close, flip, record, pause, resume, stop, cancel, discard };
+}
+function CameraPreview(props) {
+  const { own, modifiers } = splitProps(props);
+  const stream = own.recorder.stream;
+  if (!stream) return applyModifiers(sb("color", { color: { r: 0, g: 0, b: 0, a: 1 } }), modifiers);
+  return applyModifiers(
+    sb("video", {
+      url: null,
+      playing: false,
+      muted: true,
+      volume: 0,
+      rate: 1,
+      loop: false,
+      gravity: own.gravity ?? "resizeAspectFill",
+      controls: false,
+      seek: { time: 0, serial: 0 },
+      stream,
+      mirrored: own.mirrored ?? own.recorder.facing === "user"
+    }),
+    modifiers
   );
-  return { available: host !== void 0, status, time, levels, error, record, pause, resume, stop, cancel, discard, trim };
 }
 let nextId$1 = 1;
 const newId = () => nextId$1++;
@@ -4143,9 +4652,9 @@ function unsupported() {
   return new Error("unsupported: this page or app has no audio engine");
 }
 function perform$1(command2) {
-  const host = hostNow$1();
-  if (!host) return Promise.reject(unsupported());
-  return host.perform(command2);
+  const host2 = hostNow$1();
+  if (!host2) return Promise.reject(unsupported());
+  return host2.perform(command2);
 }
 class AVAudioTime {
   spec;
@@ -4751,9 +5260,9 @@ function useAudioEngine(build) {
 let nextId = 1;
 const hostNow = () => browserEnvironment.languageModel;
 function perform(command2) {
-  const host = hostNow();
-  if (!host) return Promise.reject(new GenerationError("assetsUnavailable", "This page or app has no language model."));
-  return host.perform(command2).catch((error) => {
+  const host2 = hostNow();
+  if (!host2) return Promise.reject(new GenerationError("assetsUnavailable", "This page or app has no language model."));
+  return host2.perform(command2).catch((error) => {
     throw GenerationError.from(error);
   });
 }
@@ -5236,8 +5745,9 @@ function ProgressView(props) {
 }
 function ToolbarItem(props) {
   const hidden = props.sharedBackgroundVisibility === "hidden";
-  const items = withEnvironment({ labelStyle: "iconOnly" }, props.children);
-  return sb("toolbar", hidden ? { placement: toolbarPlacement(props.placement), sharedBackground: "hidden" } : { placement: toolbarPlacement(props.placement) }, void 0, items);
+  const placement = toolbarPlacement(props.placement);
+  const items = placement === "secondary" ? props.children : withEnvironment({ labelStyle: "iconOnly" }, props.children);
+  return sb("toolbar", hidden ? { placement, sharedBackground: "hidden" } : { placement }, void 0, items);
 }
 const ToolbarItemGroup = ToolbarItem;
 function ToolbarSpacer(props) {
@@ -5439,14 +5949,14 @@ function canSignInWithApple() {
   return browserEnvironment.appleSignIn !== void 0;
 }
 async function signInWithApple(options = {}) {
-  const host = browserEnvironment.appleSignIn;
-  if (!host) throw new Error("unsupported: Sign in with Apple is not available here (configureSignInWithApple on a page)");
-  return host.signIn({ scopes: options.scopes ?? ["fullName", "email"], ...options.nonce ? { nonce: options.nonce } : {}, ...options.state ? { state: options.state } : {} });
+  const host2 = browserEnvironment.appleSignIn;
+  if (!host2) throw new Error("unsupported: Sign in with Apple is not available here (configureSignInWithApple on a page)");
+  return host2.signIn({ scopes: options.scopes ?? ["fullName", "email"], ...options.nonce ? { nonce: options.nonce } : {}, ...options.state ? { state: options.state } : {} });
 }
 async function appleCredentialState(user) {
-  const host = browserEnvironment.appleSignIn;
-  if (!host) return "unknown";
-  return host.credentialState(user);
+  const host2 = browserEnvironment.appleSignIn;
+  if (!host2) return "unknown";
+  return host2.credentialState(user);
 }
 const LABELS = { signIn: "Sign in with Apple", signUp: "Sign up with Apple", continue: "Continue with Apple" };
 function SignInWithAppleButton(props) {
@@ -5777,16 +6287,16 @@ function hostData(contents) {
   if (contents instanceof ArrayBuffer) return new Uint8Array(contents);
   return contents;
 }
-function createFileManager(host) {
+function createFileManager(host2) {
   const required = () => {
-    const files = host();
+    const files = host2();
     if (!files) throw new Error("unsupported: this page keeps no files");
     return files;
   };
-  const directories = () => host()?.directories ?? NONE;
+  const directories = () => host2()?.directories ?? NONE;
   return {
     get available() {
-      return host() !== void 0;
+      return host2() !== void 0;
     },
     get documentsDirectory() {
       return directories().documents;
@@ -5823,8 +6333,8 @@ function createFileManager(host) {
     copyItem: async (from, to) => required().copy(from, to),
     removeItem: async (url) => required().remove(url),
     loadURL: async (url) => required().loadURL(url),
-    iCloudDirectory: async () => await host()?.iCloud?.() ?? null,
-    watch: (listener) => host()?.watch?.(listener) ?? (() => {
+    iCloudDirectory: async () => await host2()?.iCloud?.() ?? null,
+    watch: (listener) => host2()?.watch?.(listener) ?? (() => {
     })
   };
 }
@@ -7420,6 +7930,19 @@ function KeyframeAnimator({
   return children(value);
 }
 export {
+  AVAsset,
+  AVAssetExportPreset1280x720,
+  AVAssetExportPreset1920x1080,
+  AVAssetExportPreset3840x2160,
+  AVAssetExportPreset640x480,
+  AVAssetExportPreset960x540,
+  AVAssetExportPresetHighestQuality,
+  AVAssetExportPresetLowQuality,
+  AVAssetExportPresetMediumQuality,
+  AVAssetExportPresetPassthrough,
+  AVAssetExportSession,
+  AVAssetImageGenerator,
+  AVAssetTrack,
   AVAudioEngine,
   AVAudioFile,
   AVAudioInputNode,
@@ -7437,8 +7960,12 @@ export {
   AVAudioUnitReverb,
   AVAudioUnitSampler,
   AVAudioUnitTimePitch,
+  AVFileType,
+  AVMediaType,
+  AVMutableComposition,
   AVPlayer,
   AVQueuePlayer,
+  AVURLAsset,
   AngularGradient,
   AreaMark,
   AsyncImage,
@@ -7446,6 +7973,9 @@ export {
   AudioPlayer,
   BarMark,
   Button,
+  CMTime,
+  CMTimeRange,
+  CameraPreview,
   Canvas,
   Capsule,
   Chart,
@@ -7617,6 +8147,7 @@ export {
   useSpeechSynthesis,
   useSystemLanguageModel,
   useUndoManager,
+  useVideoRecorder,
   useViewEnvironment,
   useWakeLock,
   weighted,