@swiftbrowser/react 0.18.3 → 0.19.0

package/dist/index.js

@@ -15,6 +15,7 @@ import { registerHostContent, notifyHostContentChange, unregisterHostContent } f
 import { createRoot } from "react-dom/client";
 import { flushSync } from "react-dom";
 import { chooseColor } from "@swiftbrowser/web/src/colorPicker";
+import { base64Encode } from "@swiftbrowser/web/src/base64";
 import { timingFor } from "@swiftbrowser/web/src/animation";
 const ViewEnvironmentContext = createContext({});
 function useViewEnvironment() {
@@ -1433,7 +1434,8 @@ function ScrollView(props) {
   const scroll = { axes, ...refresh.props, ...geometry.props };
   const handlers = refresh.handlers || geometry.handlers ? { ...refresh.handlers, ...geometry.handlers } : void 0;
   if (own.scrollTargetBehavior) scroll["snap"] = own.scrollTargetBehavior;
-  if (own.scrollDismissesKeyboard) scroll["dismissesKeyboard"] = true;
+  if (own.scrollDismissesKeyboard === true || own.scrollDismissesKeyboard === "immediately") scroll["dismissesKeyboard"] = true;
+  else if (own.scrollDismissesKeyboard === "interactively") scroll["dismissesKeyboard"] = "interactively";
   if (own.scrollIndicators === "hidden") scroll["showsIndicators"] = false;
   if (own.defaultScrollAnchor !== void 0) scroll["defaultScrollAnchor"] = unitPoint(own.defaultScrollAnchor);
   const edgeEffect = edgeEffectProp(settings);
@@ -2185,6 +2187,8 @@ const MODIFIER_KEYS = /* @__PURE__ */ new Set([
   "navigationTitle",
   "navigationBarTitleDisplayMode",
   "toolbarRole",
+  "toolbarVisibility",
+  "statusBarHidden",
   "toolbar",
   "searchable",
   "navigationDestination",
@@ -2259,6 +2263,7 @@ const MODIFIER_KEYS = /* @__PURE__ */ new Set([
   "onKeyPress",
   "sensoryFeedback",
   "textCase",
+  "textSelection",
   "coordinateSpace",
   "contentTransition",
   "scrollDisabled",
@@ -2446,7 +2451,8 @@ const STYLED_KEYS = /* @__PURE__ */ new Set([
   "matchedGeometryEffect",
   "containerRelativeFrame",
   "contentTransition",
-  "scrollDisabled"
+  "scrollDisabled",
+  "textSelection"
 ]);
 const ENVIRONMENT_KEYS = /* @__PURE__ */ new Set([
   "buttonStyle",
@@ -2598,6 +2604,17 @@ function apply(key, value, node, sides) {
     case "toolbarRole":
       sides.push(sb(PREF_KIND, { toolbarRole: value }, void 0, void 0, "navscreen"));
       return node;
+    case "toolbarVisibility": {
+      const bars = value;
+      const props = {};
+      if (bars.navigationBar && bars.navigationBar !== "automatic") props["navigationBarHidden"] = bars.navigationBar === "hidden";
+      if (bars.bottomBar && bars.bottomBar !== "automatic") props["bottomBarHidden"] = bars.bottomBar === "hidden";
+      sides.push(sb(PREF_KIND, props, void 0, void 0, "navscreen"));
+      return node;
+    }
+    case "statusBarHidden":
+      sides.push(sb(PREF_KIND, { statusBarHidden: Boolean(value) }, void 0, void 0, "navscreen"));
+      return node;
     case "toolbar":
       sides.push(sb(HOIST_KIND, void 0, void 0, value, "navscreen"));
       return node;
@@ -2631,8 +2648,8 @@ function apply(key, value, node, sides) {
       const count = Math.floor(spec.count ?? 1);
       const props = count > 1 ? { count } : {};
       if ("perform" in spec) {
-        const { perform } = spec;
-        return sb("tapgesture", { ...props, location: true }, { tap: (event) => perform({ x: event.x ?? 0, y: event.y ?? 0 }) }, node);
+        const { perform: perform2 } = spec;
+        return sb("tapgesture", { ...props, location: true }, { tap: (event) => perform2({ x: event.x ?? 0, y: event.y ?? 0 }) }, node);
       }
       return sb("tapgesture", props, { tap: () => spec.action() }, node);
     }
@@ -2852,6 +2869,8 @@ function apply(key, value, node, sides) {
     }
     case "scrollDisabled":
       return styled({ scrollDisabled: value === true }, node);
+    case "textSelection":
+      return styled({ textSelection: value === "enabled" }, node);
     case "contentTransition": {
       if (value === "identity") return node;
       if (typeof value === "object") {
@@ -3574,6 +3593,848 @@ function useAudioRecorder(options = {}) {
   );
   return { available: host !== void 0, status, time, levels, error, record, pause, resume, stop, cancel, discard, trim };
 }
+let nextId$1 = 1;
+const newId = () => nextId$1++;
+const hostNow$1 = () => browserEnvironment.audioEngine;
+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);
+}
+class AVAudioTime {
+  spec;
+  constructor(sampleTime, atRate) {
+    this.spec = { sampleTime: Math.round(sampleTime), sampleRate: atRate };
+  }
+  static secondsFromNow(seconds) {
+    const time = Object.create(AVAudioTime.prototype);
+    time.spec = { delay: Math.max(0, seconds) };
+    return time;
+  }
+  get isSampleTimeValid() {
+    return "sampleTime" in this.spec;
+  }
+  get sampleTime() {
+    return "sampleTime" in this.spec ? this.spec.sampleTime : 0;
+  }
+  get sampleRate() {
+    return "sampleTime" in this.spec ? this.spec.sampleRate : 0;
+  }
+  /** The time in seconds: a sample time's place on its timeline, or the delay. */
+  get seconds() {
+    return "sampleTime" in this.spec ? this.spec.sampleTime / this.spec.sampleRate : this.spec.delay;
+  }
+}
+const released = typeof FinalizationRegistry !== "undefined" ? new FinalizationRegistry((id) => void perform$1({ action: "release", id }).catch(() => void 0)) : null;
+class AVAudioFile {
+  constructor(id, url, length, processingFormat) {
+    this.id = id;
+    this.url = url;
+    this.length = length;
+    this.processingFormat = processingFormat;
+    released?.register(this, id, this);
+  }
+  id;
+  url;
+  length;
+  processingFormat;
+  /** Where the next `read` starts, in frames. */
+  framePosition = 0;
+  /** Opens a file for reading; rejects with `notFound: …` or `decode: …`. */
+  static async open(url) {
+    const id = newId();
+    const info = await perform$1({ action: "openFile", file: id, url });
+    return new AVAudioFile(id, url, info.length, { sampleRate: info.sampleRate, channelCount: info.channelCount });
+  }
+  /** Seconds. */
+  get duration() {
+    return this.length / this.processingFormat.sampleRate;
+  }
+  /** Reads frames from `framePosition` into `buffer` (up to its capacity, or `frameCount`) and moves past them. */
+  async read(into, frameCount) {
+    const frames = Math.max(0, Math.min(frameCount ?? into.frameCapacity, into.frameCapacity, this.length - this.framePosition));
+    const info = await perform$1({ action: "readFile", file: this.id, buffer: into.id, start: this.framePosition, frames });
+    into.frameLength = info.frameLength;
+    into.format = { sampleRate: info.sampleRate, channelCount: info.channelCount };
+    this.framePosition += info.frameLength;
+  }
+  /** Lets the host free the decoded audio (what a scheduled segment still plays keeps playing). */
+  close() {
+    released?.unregister(this);
+    void perform$1({ action: "release", id: this.id }).catch(() => void 0);
+  }
+}
+class AVAudioPCMBuffer {
+  constructor(format, frameCapacity) {
+    this.format = format;
+    this.frameCapacity = frameCapacity;
+    released?.register(this, this.id, this);
+  }
+  format;
+  frameCapacity;
+  id = newId();
+  frameLength = 0;
+  /** Seconds of audio it holds. */
+  get duration() {
+    return this.frameLength / this.format.sampleRate;
+  }
+  /** Fills the buffer with the app's samples, one array per channel (up to its capacity). */
+  async write(channels) {
+    const frames = Math.min(this.frameCapacity, ...channels.map((data) => data.length));
+    await perform$1({
+      action: "writeBuffer",
+      buffer: this.id,
+      sampleRate: this.format.sampleRate,
+      channels: channels.map((data) => data.length === frames ? data : data.subarray(0, frames))
+    });
+    this.frameLength = frames;
+    this.format = { sampleRate: this.format.sampleRate, channelCount: channels.length };
+  }
+  /** Lets the host free the audio. */
+  close() {
+    released?.unregister(this);
+    void perform$1({ action: "release", id: this.id }).catch(() => void 0);
+  }
+}
+class AVAudioNode {
+  id = newId();
+  /** The engine it is attached to, or null. */
+  engine = null;
+  values = {};
+  get(key, fallback) {
+    return this.values[key] ?? fallback;
+  }
+  set(key, value) {
+    this.values[key] = value;
+    this.engine?.fire({ action: "set", node: this.id, values: { [key]: value } });
+  }
+  /** The properties to attach it with. */
+  attachValues() {
+    return { ...this.values };
+  }
+  /** How many EQ bands it has (only an EQ has any). */
+  get bandCount() {
+    return void 0;
+  }
+  /** What its engine must be for a call to reach it. */
+  attached() {
+    if (!this.engine) throw new Error("notAttached: attach the node to an engine first");
+    return this.engine;
+  }
+  /** Its output's level now (0 silent … 1 at 0 dB, from -50 dB), as a tap on it would measure; 0 when not attached. */
+  async meter() {
+    if (!this.engine) return 0;
+    const result = await this.engine.send({ action: "meter", node: this.id });
+    return typeof result?.level === "number" ? result.level : 0;
+  }
+}
+class MixingNode extends AVAudioNode {
+  get volume() {
+    return this.get("volume", 1);
+  }
+  set volume(value) {
+    this.set("volume", value);
+  }
+  get pan() {
+    return this.get("pan", 0);
+  }
+  set pan(value) {
+    this.set("pan", value);
+  }
+}
+class AVAudioMixerNode extends MixingNode {
+  kind = "mixer";
+  get outputVolume() {
+    return this.get("outputVolume", 1);
+  }
+  set outputVolume(value) {
+    this.set("outputVolume", value);
+  }
+}
+class AVAudioOutputNode extends AVAudioNode {
+  kind = null;
+}
+class AVAudioInputNode extends MixingNode {
+  kind = null;
+}
+class AVAudioPlayerNode extends MixingNode {
+  kind = "player";
+  playing = false;
+  get isPlaying() {
+    return this.playing && this.engine?.isRunning === true;
+  }
+  scheduleFile(file, at = null, completionHandler) {
+    return this.schedule({ action: "scheduleFile", node: this.id, file: file.id, ...at ? { at: at.spec } : {} }, completionHandler);
+  }
+  scheduleSegment(file, startingFrame, frameCount, at = null, completionHandler) {
+    return this.schedule(
+      {
+        action: "scheduleFile",
+        node: this.id,
+        file: file.id,
+        start: Math.max(0, Math.floor(startingFrame)),
+        frames: Math.max(0, Math.floor(frameCount)),
+        ...at ? { at: at.spec } : {}
+      },
+      completionHandler
+    );
+  }
+  scheduleBuffer(buffer, at = null, options = {}, completionHandler) {
+    const command2 = {
+      action: "scheduleBuffer",
+      node: this.id,
+      buffer: buffer.id,
+      ...at ? { at: at.spec } : {}
+    };
+    if (options.loops) command2.loops = true;
+    if (options.interruptsAtLoop) command2.interruptsAtLoop = true;
+    else if (options.interrupts) command2.interrupts = true;
+    return this.schedule(command2, completionHandler);
+  }
+  schedule(command2, completionHandler) {
+    const engine = this.attached();
+    return engine.send(command2).then(() => completionHandler?.());
+  }
+  /** Starts (or resumes) the timeline, now or at `at`; the engine must be running. */
+  play(at = null) {
+    const engine = this.attached();
+    this.playing = true;
+    engine.fire({ action: "play", node: this.id, ...at ? { at: at.spec } : {} });
+  }
+  /** Holds the timeline where it is; `play()` goes on from there. */
+  pause() {
+    this.playing = false;
+    this.engine?.fire({ action: "pausePlayer", node: this.id });
+  }
+  /** Drops everything scheduled (each completion called) and returns the timeline to 0. */
+  stop() {
+    this.playing = false;
+    this.engine?.fire({ action: "stopPlayer", node: this.id });
+  }
+  /** Where the timeline is now (`playerTime(forNodeTime: lastRenderTime)`), or null before it plays. */
+  async playerTime() {
+    const time = await this.attached().send({ action: "playerTime", node: this.id });
+    return time && typeof time.sampleTime === "number" ? new AVAudioTime(time.sampleTime, time.sampleRate) : null;
+  }
+  /** Called by the engine when it stops: the player stops with it. */
+  engineStopped() {
+    this.playing = false;
+  }
+}
+const NOTE_CLASSES = { c: 0, d: 2, e: 4, f: 5, g: 7, a: 9, b: 11 };
+function noteInName(url) {
+  const name = decodeURIComponent(url.split(/[/\\]/).pop() ?? "").replace(/\.[^.]*$/, "");
+  const named = [...name.matchAll(/(?:^|[^A-Za-z])([A-Ga-g])([#♯]|b|♭)?(-?\d)(?!\d)/g)].pop();
+  if (named) {
+    const pitchClass = NOTE_CLASSES[named[1].toLowerCase()];
+    const accidental = named[2] === "#" || named[2] === "♯" ? 1 : named[2] ? -1 : 0;
+    const note = (Number(named[3]) + 1) * 12 + pitchClass + accidental;
+    return note >= 0 && note <= 127 ? note : null;
+  }
+  const numbered = [...name.matchAll(/(?:^|\D)(\d{1,3})(?!\d)/g)].pop();
+  if (numbered) {
+    const note = Number(numbered[1]);
+    return note <= 127 ? note : null;
+  }
+  return null;
+}
+function samplerZones(samples) {
+  const sorted = [...samples].sort((a, b) => a.root - b.root).filter((sample, i, all) => i === 0 || sample.root !== all[i - 1].root);
+  return sorted.map((sample, i) => {
+    const below = sorted[i - 1];
+    const above = sorted[i + 1];
+    return {
+      file: sample.file,
+      root: sample.root,
+      low: below ? Math.floor((below.root + sample.root) / 2) + 1 : 0,
+      high: above ? Math.floor((sample.root + above.root) / 2) : 127
+    };
+  });
+}
+class AVAudioUnitSampler extends MixingNode {
+  kind = "sampler";
+  files = [];
+  /** Decibels, -90 … 12. */
+  get overallGain() {
+    return this.get("overallGain", 0);
+  }
+  set overallGain(value) {
+    this.set("overallGain", value);
+  }
+  /** Cents, -2400 … 2400. */
+  get globalTuning() {
+    return this.get("globalTuning", 0);
+  }
+  set globalTuning(value) {
+    this.set("globalTuning", value);
+  }
+  /** -100 left … 100 right. */
+  get stereoPan() {
+    return this.get("stereoPan", 0);
+  }
+  set stereoPan(value) {
+    this.set("stereoPan", value);
+  }
+  async loadAudioFiles(urls, options = {}) {
+    const engine = this.attached();
+    const roots2 = urls.map((url, i) => options.rootNotes?.[i] ?? noteInName(url) ?? 60);
+    const files = await Promise.all(urls.map((url) => AVAudioFile.open(url)));
+    const zones = samplerZones(files.map((file, i) => ({ file: file.id, root: roots2[i] })));
+    await engine.send({ action: "loadZones", node: this.id, zones, attack: options.attack ?? 2e-3, release: options.release ?? 0.15 });
+    const previous = this.files;
+    this.files = files;
+    for (const file of previous) file.close();
+  }
+  /** Loads an `.aupreset`, a DLS or a SoundFont's first instrument (natively; a page rejects with `unsupported: …`). */
+  async loadInstrument(url) {
+    await this.attached().send({ action: "loadInstrument", node: this.id, url });
+  }
+  /** Loads one instrument of a SoundFont or DLS bank by program and bank (natively; a page rejects with `unsupported: …`). */
+  async loadSoundBankInstrument(url, program, bankMSB = 121, bankLSB = 0) {
+    await this.attached().send({ action: "loadInstrument", node: this.id, url, program, bankMSB, bankLSB });
+  }
+  startNote(note, withVelocity, onChannel = 0) {
+    this.attached().fire({ action: "startNote", node: this.id, note: Math.round(note), velocity: Math.round(withVelocity), channel: onChannel });
+  }
+  stopNote(note, onChannel = 0) {
+    this.attached().fire({ action: "stopNote", node: this.id, note: Math.round(note), channel: onChannel });
+  }
+  /** A MIDI controller: 64 the sustain pedal, 7 volume, 11 expression, 10 pan, 123 all notes off. */
+  sendController(controller, withValue, onChannel = 0) {
+    this.attached().fire({ action: "controller", node: this.id, controller, value: Math.round(withValue), channel: onChannel });
+  }
+  /** The pitch wheel: 0 … 16383, 8192 centered (±2 semitones). */
+  sendPitchBend(pitchbend, onChannel = 0) {
+    this.attached().fire({ action: "pitchBend", node: this.id, value: Math.round(pitchbend), channel: onChannel });
+  }
+}
+class AVAudioUnitEffect extends AVAudioNode {
+  get bypass() {
+    return this.get("bypass", false);
+  }
+  set bypass(value) {
+    this.set("bypass", value);
+  }
+}
+class AVAudioUnitReverb extends AVAudioUnitEffect {
+  kind = "reverb";
+  constructor() {
+    super();
+    this.values["preset"] = "mediumHall";
+    this.values["wetDryMix"] = 100;
+  }
+  get wetDryMix() {
+    return this.get("wetDryMix", 100);
+  }
+  set wetDryMix(value) {
+    this.set("wetDryMix", value);
+  }
+  loadFactoryPreset(preset) {
+    this.values["preset"] = preset;
+    this.engine?.fire({ action: "preset", node: this.id, preset });
+  }
+}
+class AVAudioUnitDelay extends AVAudioUnitEffect {
+  kind = "delay";
+  constructor() {
+    super();
+    Object.assign(this.values, { delayTime: 1, feedback: 50, lowPassCutoff: 15e3, wetDryMix: 100 });
+  }
+  get delayTime() {
+    return this.get("delayTime", 1);
+  }
+  set delayTime(value) {
+    this.set("delayTime", value);
+  }
+  get feedback() {
+    return this.get("feedback", 50);
+  }
+  set feedback(value) {
+    this.set("feedback", value);
+  }
+  get lowPassCutoff() {
+    return this.get("lowPassCutoff", 15e3);
+  }
+  set lowPassCutoff(value) {
+    this.set("lowPassCutoff", value);
+  }
+  get wetDryMix() {
+    return this.get("wetDryMix", 100);
+  }
+  set wetDryMix(value) {
+    this.set("wetDryMix", value);
+  }
+}
+class AVAudioUnitDistortion extends AVAudioUnitEffect {
+  kind = "distortion";
+  constructor() {
+    super();
+    Object.assign(this.values, { preGain: -6, wetDryMix: 50 });
+  }
+  get preGain() {
+    return this.get("preGain", -6);
+  }
+  set preGain(value) {
+    this.set("preGain", value);
+  }
+  get wetDryMix() {
+    return this.get("wetDryMix", 50);
+  }
+  set wetDryMix(value) {
+    this.set("wetDryMix", value);
+  }
+  loadFactoryPreset(preset) {
+    this.values["preset"] = preset;
+    this.engine?.fire({ action: "preset", node: this.id, preset });
+  }
+}
+class AVAudioUnitEQFilterParameters {
+  constructor(eq, index) {
+    this.eq = eq;
+    this.index = index;
+  }
+  eq;
+  index;
+  key(field) {
+    return `bands.${this.index}.${field}`;
+  }
+  get filterType() {
+    return this.eq.band(this.key("filterType"), "parametric");
+  }
+  set filterType(value) {
+    this.eq.setBand(this.key("filterType"), value);
+  }
+  /** Hz. */
+  get frequency() {
+    return this.eq.band(this.key("frequency"), 1e3);
+  }
+  set frequency(value) {
+    this.eq.setBand(this.key("frequency"), value);
+  }
+  /** Octaves (0.05 … 5). */
+  get bandwidth() {
+    return this.eq.band(this.key("bandwidth"), 0.5);
+  }
+  set bandwidth(value) {
+    this.eq.setBand(this.key("bandwidth"), value);
+  }
+  /** Decibels (-96 … 24). */
+  get gain() {
+    return this.eq.band(this.key("gain"), 0);
+  }
+  set gain(value) {
+    this.eq.setBand(this.key("gain"), value);
+  }
+  get bypass() {
+    return this.eq.band(this.key("bypass"), true);
+  }
+  set bypass(value) {
+    this.eq.setBand(this.key("bypass"), value);
+  }
+}
+class AVAudioUnitEQ extends AVAudioUnitEffect {
+  kind = "eq";
+  bands;
+  constructor(numberOfBands = 1) {
+    super();
+    const count = Math.max(1, Math.min(32, Math.floor(numberOfBands)));
+    this.bands = Array.from({ length: count }, (_, i) => new AVAudioUnitEQFilterParameters(this, i));
+    for (let i = 0; i < count; i += 1) {
+      Object.assign(this.values, {
+        [`bands.${i}.filterType`]: "parametric",
+        [`bands.${i}.frequency`]: 1e3,
+        [`bands.${i}.bandwidth`]: 0.5,
+        [`bands.${i}.gain`]: 0,
+        [`bands.${i}.bypass`]: true
+      });
+    }
+  }
+  get bandCount() {
+    return this.bands.length;
+  }
+  get globalGain() {
+    return this.get("globalGain", 0);
+  }
+  set globalGain(value) {
+    this.set("globalGain", value);
+  }
+  /** A band's field (for `AVAudioUnitEQFilterParameters`). */
+  band(key, fallback) {
+    return this.values[key] ?? fallback;
+  }
+  setBand(key, value) {
+    this.set(key, value);
+  }
+}
+class AVAudioUnitTimePitch extends AVAudioUnitEffect {
+  kind = "timePitch";
+  get pitch() {
+    return this.get("pitch", 0);
+  }
+  set pitch(value) {
+    this.set("pitch", value);
+  }
+  get rate() {
+    return this.get("rate", 1);
+  }
+  set rate(value) {
+    this.set("rate", value);
+  }
+  get overlap() {
+    return this.get("overlap", 8);
+  }
+  set overlap(value) {
+    this.set("overlap", value);
+  }
+}
+const engines = typeof FinalizationRegistry !== "undefined" ? new FinalizationRegistry((id) => void perform$1({ action: "destroy", engine: id }).catch(() => void 0)) : null;
+class AVAudioEngine {
+  id = newId();
+  mainMixerNode = new AVAudioMixerNode();
+  outputNode = new AVAudioOutputNode();
+  inputNode = new AVAudioInputNode();
+  attachedNodes = /* @__PURE__ */ new Set();
+  /** Where failures of calls that answer nothing go (a console warning by default). */
+  onError = (error) => console.warn(`AVAudioEngine: ${error.message}`);
+  running = false;
+  disposed = false;
+  /** Whether this page or app has an audio engine. */
+  static get isAvailable() {
+    return hostNow$1() !== void 0;
+  }
+  constructor() {
+    for (const node of [this.mainMixerNode, this.outputNode, this.inputNode]) {
+      node.engine = this;
+      this.attachedNodes.add(node);
+    }
+    this.fire({ action: "create", engine: this.id, mixer: this.mainMixerNode.id, output: this.outputNode.id, input: this.inputNode.id });
+    engines?.register(this, this.id, this);
+  }
+  get isRunning() {
+    return this.running;
+  }
+  /** Sends a command and answers its result. */
+  send(command2) {
+    if (this.disposed) return Promise.reject(new Error("disposed: the engine was disposed"));
+    return perform$1(command2);
+  }
+  /** Sends a command that answers nothing; a failure goes to `onError`. */
+  fire(command2) {
+    this.send(command2).catch((error) => this.onError(error instanceof Error ? error : new Error(String(error))));
+  }
+  attach(node) {
+    if (node.engine === this) return;
+    if (node.engine) throw new Error("attached: the node is attached to another engine");
+    if (!node.kind) throw new Error("unsupported: an engine makes its own mixer, output and input");
+    node.engine = this;
+    this.attachedNodes.add(node);
+    const bands = node.bandCount;
+    this.fire({ action: "attach", engine: this.id, node: node.id, kind: node.kind, values: node.attachValues(), ...bands !== void 0 ? { bands } : {} });
+  }
+  detach(node) {
+    if (node.engine !== this || !node.kind) return;
+    this.fire({ action: "detach", engine: this.id, node: node.id });
+    if (node instanceof AVAudioPlayerNode) node.engineStopped();
+    node.engine = null;
+    this.attachedNodes.delete(node);
+  }
+  /**
+   * Connects `from`'s output to `to` (an array: to each of them), replacing
+   * where it went before; a node that is not a mixer takes one input, so
+   * what was connected into it is let go. `format` is accepted for Swift's
+   * shape: the host picks one that fits both ends.
+   */
+  connect(from, to, format = null) {
+    const destinations = Array.isArray(to) ? to : [to];
+    for (const node of [from, ...destinations]) {
+      if (node.engine !== this) throw new Error("notAttached: attach both nodes to the engine before connecting them");
+    }
+    this.fire({ action: "connect", engine: this.id, from: from.id, to: destinations.map((node) => node.id) });
+  }
+  disconnectNodeOutput(node) {
+    this.fire({ action: "disconnectOutput", engine: this.id, node: node.id });
+  }
+  disconnectNodeInput(node) {
+    this.fire({ action: "disconnectInput", engine: this.id, node: node.id });
+  }
+  prepare() {
+    this.fire({ action: "prepare", engine: this.id });
+  }
+  /** Starts rendering; with the input connected, asks for the microphone (rejecting `permission: …` when refused). */
+  async start() {
+    await this.send({ action: "start", engine: this.id });
+    this.running = true;
+  }
+  /** Pauses rendering; players hold their place and play on at `start()`. */
+  pause() {
+    this.running = false;
+    this.fire({ action: "pause", engine: this.id });
+  }
+  /** Stops rendering; players stop and drop what they had scheduled. */
+  stop() {
+    this.running = false;
+    for (const node of this.attachedNodes) if (node instanceof AVAudioPlayerNode) node.engineStopped();
+    this.fire({ action: "stop", engine: this.id });
+  }
+  /** Silences every node (players stop, notes end) without stopping the engine. */
+  reset() {
+    for (const node of this.attachedNodes) if (node instanceof AVAudioPlayerNode) node.engineStopped();
+    this.fire({ action: "reset", engine: this.id });
+  }
+  /** Stops the engine and frees it on the host; it cannot be used after. */
+  dispose() {
+    if (this.disposed) return;
+    engines?.unregister(this);
+    void perform$1({ action: "destroy", engine: this.id }).catch(() => void 0);
+    this.disposed = true;
+    this.running = false;
+    for (const node of this.attachedNodes) node.engine = null;
+    this.attachedNodes.clear();
+  }
+}
+function useAudioEngine(build) {
+  const [engine] = useState(() => {
+    if (!AVAudioEngine.isAvailable) return null;
+    const made = new AVAudioEngine();
+    build?.(made);
+    return made;
+  });
+  useEffect(() => () => engine?.dispose(), [engine]);
+  return engine;
+}
+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) => {
+    throw GenerationError.from(error);
+  });
+}
+const KINDS = {
+  unavailable: "assetsUnavailable",
+  context: "exceededContextWindowSize",
+  guardrail: "guardrailViolation",
+  language: "unsupportedLanguageOrLocale",
+  concurrent: "concurrentRequests",
+  rateLimited: "rateLimited",
+  refusal: "refusal"
+};
+class GenerationError extends Error {
+  constructor(kind, message) {
+    super(message);
+    this.kind = kind;
+    this.name = "GenerationError";
+  }
+  kind;
+  /** The error a host's tagged message (`context: …`) stands for. */
+  static from(error) {
+    if (error instanceof GenerationError) return error;
+    const message = error instanceof Error ? error.message : String(error);
+    const match = /^(\w+): ?([\s\S]*)$/.exec(message);
+    const kind = match ? KINDS[match[1]] : void 0;
+    return kind ? new GenerationError(kind, match[2]) : new GenerationError("unknown", message);
+  }
+}
+class SystemLanguageModel {
+  static default = new SystemLanguageModel();
+  constructor() {
+  }
+  /** Views showing the availability, asked again when a download starts or the model goes. */
+  listeners = /* @__PURE__ */ new Set();
+  /** Whether the model can answer now, or why not. */
+  async availability() {
+    if (!hostNow()) return { status: "unavailable", reason: "deviceNotEligible" };
+    try {
+      return await perform({ action: "availability" });
+    } catch {
+      return { status: "unavailable", reason: "deviceNotEligible" };
+    }
+  }
+  async isAvailable() {
+    return (await this.availability()).status === "available";
+  }
+  /**
+   * Starts fetching a model the app fetches itself (availability's
+   * `download`), which the viewer asked for: show its size first. Not part
+   * of FoundationModels, whose model the system manages.
+   */
+  async download() {
+    await perform({ action: "download" });
+    this.changed();
+  }
+  /**
+   * Makes the model with this `id` (one of availability's `models`) the one
+   * that answers, from the next session on; remembered across launches.
+   */
+  async selectModel(id) {
+    await perform({ action: "select", id });
+    this.changed();
+  }
+  /** Stops such a download, or removes the model from the device to free its space. */
+  async deleteDownload() {
+    await perform({ action: "deleteDownload" });
+    this.changed();
+  }
+  /** @internal `useSystemLanguageModel` hears downloads start and models go. */
+  listen(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  changed() {
+    for (const listener of this.listeners) listener();
+  }
+}
+function useSystemLanguageModel(model = SystemLanguageModel.default) {
+  const [availability, setAvailability] = useState(null);
+  useEffect(() => {
+    let live = true;
+    let timer;
+    const check = () => {
+      if (timer !== void 0) clearTimeout(timer);
+      timer = void 0;
+      void model.availability().then((next) => {
+        if (!live) return;
+        setAvailability((current) => JSON.stringify(current) === JSON.stringify(next) ? current : next);
+        if (timer !== void 0) return;
+        if (next.download?.progress !== void 0) timer = setTimeout(check, 1e3);
+        else if (next.status === "unavailable" && next.reason === "modelNotReady" && !next.download) timer = setTimeout(check, 5e3);
+      });
+    };
+    check();
+    const stop = model.listen(check);
+    return () => {
+      live = false;
+      stop();
+      if (timer !== void 0) clearTimeout(timer);
+    };
+  }, [model]);
+  return availability;
+}
+class ResponseStream {
+  /** @internal Made by `LanguageModelSession.streamResponse`. */
+  constructor(session, opened, prompt, options, ended) {
+    this.ended = ended;
+    this.started = opened.then(
+      () => perform({ action: "stream", session: session.id, stream: this.id, prompt, ...options ? { options } : {} })
+    );
+    this.started.catch(() => this.end());
+  }
+  ended;
+  id = nextId++;
+  started;
+  finished = false;
+  last = { content: "" };
+  async *[Symbol.asyncIterator]() {
+    try {
+      await this.started;
+      while (!this.finished) {
+        const { content, done } = await perform({ action: "next", stream: this.id });
+        if (done) this.end();
+        if (content !== this.last.content) {
+          this.last = { content };
+          yield this.last;
+        }
+      }
+    } catch (error) {
+      this.end();
+      throw error;
+    } finally {
+      this.cancel();
+    }
+  }
+  /** The whole response, once it has ended. */
+  async collect() {
+    for await (const snapshot of this) this.last = snapshot;
+    return this.last;
+  }
+  /** Stops the response; the iteration ends with what came so far. */
+  cancel() {
+    if (this.finished) return;
+    this.end();
+    void this.started.then(() => perform({ action: "cancel", stream: this.id })).catch(() => {
+    });
+  }
+  end() {
+    if (this.finished) return;
+    this.finished = true;
+    this.ended();
+  }
+}
+class LanguageModelSession {
+  id = nextId++;
+  instructions;
+  tools;
+  opened;
+  responses = 0;
+  closed = false;
+  constructor(options = {}) {
+    this.instructions = options.instructions;
+    this.tools = options.tools ?? [];
+    const tools = this.tools.map(({ name, description, parameters }) => ({ name, description, parameters }));
+    this.opened = perform({
+      action: "open",
+      session: this.id,
+      ...options.instructions ? { instructions: options.instructions } : {},
+      ...tools.length > 0 ? { tools } : {}
+    });
+    this.opened.catch(() => {
+    });
+    if (tools.length > 0) void this.opened.then(() => this.serveTools()).catch(() => {
+    });
+  }
+  /** Runs the model's tool calls as they come, until the session closes. */
+  async serveTools() {
+    while (!this.closed) {
+      const request = await perform({ action: "toolCall", session: this.id });
+      if (!request || request.closed || request.call === void 0) return;
+      const tool = this.tools.find((candidate) => candidate.name === request.name);
+      let answer;
+      try {
+        if (!tool) throw new Error(`no tool named ${String(request.name)}`);
+        const output = await tool.call(request.arguments ?? {});
+        answer = { output: typeof output === "string" ? output : JSON.stringify(output ?? null) };
+      } catch (error) {
+        answer = { error: error instanceof Error ? error.message : String(error) };
+      }
+      await perform({ action: "toolResult", session: this.id, call: request.call, ...answer });
+    }
+  }
+  /** Whether a response is under way. */
+  get isResponding() {
+    return this.responses > 0;
+  }
+  /** Loads the model ahead of the first prompt, so it answers sooner. */
+  prewarm() {
+    void this.opened.then(() => perform({ action: "prewarm", session: this.id })).catch(() => {
+    });
+  }
+  async respond(to, options) {
+    this.responses += 1;
+    try {
+      await this.opened;
+      return await perform({ action: "respond", session: this.id, prompt: to, ...options ? { options } : {} });
+    } finally {
+      this.responses -= 1;
+    }
+  }
+  streamResponse(to, options) {
+    this.responses += 1;
+    return new ResponseStream(this, this.opened, to, options, () => {
+      this.responses -= 1;
+    });
+  }
+  /** Ends the session: the host lets its conversation go. */
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    void this.opened.then(() => perform({ action: "close", session: this.id })).catch(() => {
+    });
+  }
+}
 function wakeLockAPI() {
   const nav = globalThis.navigator;
   return nav?.wakeLock ?? null;
@@ -4502,6 +5363,9 @@ function Form(props) {
 function Section(props) {
   const { own, modifiers } = splitProps(props);
   const pinned = useContext(PinnedContext);
+  const [expanded, setExpanded] = own.isExpanded !== void 0 ? readBinding(own.isExpanded, own.onExpandedChange) : [true, () => {
+  }];
+  const collapsible = own.isExpanded !== void 0;
   let header = supplement(own.header);
   let footer = supplement(own.footer);
   if (pinned?.includes("sectionHeaders") && header.text !== null && !header.view) header = { text: null, view: /* @__PURE__ */ jsx(Text, { children: header.text }) };
@@ -4510,7 +5374,15 @@ function Section(props) {
   if (header.view) children.push(sb("sectionheader", {}, void 0, header.view));
   if (own.children !== void 0) children.push(wrapRows(own.children));
   if (footer.view) children.push(sb("sectionfooter", {}, void 0, footer.view));
-  return applyModifiers(sb("section", { header: header.text, footer: footer.text }, void 0, children), modifiers);
+  return applyModifiers(
+    sb(
+      "section",
+      collapsible ? { header: header.text, footer: footer.text, collapsible: true, expanded } : { header: header.text, footer: footer.text },
+      collapsible ? { tap: () => setExpanded(!expanded) } : void 0,
+      children
+    ),
+    modifiers
+  );
 }
 function wrapRows(children) {
   let offset = 0;
@@ -5182,22 +6054,10 @@ function DisclosureGroup(props) {
   const label = typeof own.label === "string" ? /* @__PURE__ */ jsx(Text, { children: own.label }) : own.label;
   const toggle = () => withAnimation({ type: "easeInOut", duration: 0.25 }, () => setExpanded(!expanded));
   return applyModifiers(
-    /* @__PURE__ */ jsxs(VStack, { alignment: "leading", spacing: 0, children: [
-      /* @__PURE__ */ jsx(Button, { action: toggle, buttonStyle: "plain", children: /* @__PURE__ */ jsxs(HStack, { children: [
-        styled({ foreground: { hierarchical: 1 } }, label),
-        /* @__PURE__ */ jsx(Spacer, {}),
-        /* @__PURE__ */ jsx(
-          Image$1,
-          {
-            systemName: "chevron.right",
-            font: { textStyle: "footnote", weight: "semibold" },
-            foregroundStyle: "tint",
-            rotationEffect: expanded ? 90 : 0
-          }
-        )
-      ] }) }),
-      expanded && /* @__PURE__ */ jsx(VStack, { alignment: "leading", spacing: 8, padding: ["top", 8], transition: { kind: "opacity" }, children: own.children })
-    ] }),
+    sb("disclosuregroup", { expanded }, { tap: toggle }, [
+      /* @__PURE__ */ jsx(Fragment, { children: sb("zstack", { alignment: "center" }, void 0, label) }, "label"),
+      /* @__PURE__ */ jsx(Fragment, { children: own.children }, "content")
+    ]),
     modifiers
   );
 }
@@ -5293,16 +6153,46 @@ function ColorPicker(props) {
     modifiers
   );
 }
+const isFile = (item) => typeof item === "object" && !(item instanceof URL) && "data" in item;
+const MIME_BY_EXTENSION = {
+  txt: "text/plain",
+  md: "text/markdown",
+  csv: "text/csv",
+  json: "application/json",
+  html: "text/html",
+  pdf: "application/pdf",
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  svg: "image/svg+xml",
+  m4a: "audio/mp4",
+  mp3: "audio/mpeg",
+  mp4: "video/mp4",
+  mov: "video/quicktime",
+  zip: "application/zip"
+};
+async function sharedFile(file) {
+  const bytes = typeof file.data === "string" ? new TextEncoder().encode(file.data) : file.data instanceof Uint8Array ? file.data : file.data instanceof ArrayBuffer ? new Uint8Array(file.data) : new Uint8Array(await file.data.arrayBuffer());
+  const extension = file.name.includes(".") ? file.name.slice(file.name.lastIndexOf(".") + 1).toLowerCase() : "";
+  return { name: file.name, type: file.type ?? MIME_BY_EXTENSION[extension] ?? "application/octet-stream", data: base64Encode(bytes) };
+}
+async function shareParamsOf(props) {
+  const item = props.item;
+  const isURL = item instanceof URL || typeof item === "string" && /^[a-z][a-z0-9+.-]*:\/\//i.test(item);
+  const params = {};
+  if (props.subject) params.title = props.subject;
+  if (isURL) params.url = String(item);
+  const text = [props.message, typeof item === "string" && !isURL ? item : null].filter(Boolean).join("\n");
+  if (text) params.text = text;
+  const files = [...isFile(item) ? [item] : [], ...props.files ?? []];
+  if (files.length) params.files = await Promise.all(files.map(sharedFile));
+  return params;
+}
 function ShareLink(props) {
   const { own, modifiers } = splitProps(props);
   const share = () => {
-    const isURL = own.item instanceof URL || /^[a-z][a-z0-9+.-]*:\/\//i.test(own.item);
-    const params = {};
-    if (own.subject) params["title"] = own.subject;
-    if (isURL) params["url"] = String(own.item);
-    const text = [own.message, isURL ? null : String(own.item)].filter(Boolean).join("\n");
-    if (text) params["text"] = text;
-    performHostRequest({ op: "request", id: 0, kind: "share", params }, browserEnvironment).catch((error) => console.error(error));
+    shareParamsOf(own).then((params) => performHostRequest({ op: "request", id: 0, kind: "share", params }, browserEnvironment)).catch((error) => console.error(error));
   };
   return applyModifiers(
     /* @__PURE__ */ jsx(Button, { action: share, children: own.children ?? /* @__PURE__ */ jsx(Label, { title: own.title ?? "Share", systemImage: "square.and.arrow.up" }) }),
@@ -5923,6 +6813,23 @@ function KeyframeAnimator({
   return children(value);
 }
 export {
+  AVAudioEngine,
+  AVAudioFile,
+  AVAudioInputNode,
+  AVAudioMixerNode,
+  AVAudioNode,
+  AVAudioOutputNode,
+  AVAudioPCMBuffer,
+  AVAudioPlayerNode,
+  AVAudioTime,
+  AVAudioUnitDelay,
+  AVAudioUnitDistortion,
+  AVAudioUnitEQ,
+  AVAudioUnitEQFilterParameters,
+  AVAudioUnitEffect,
+  AVAudioUnitReverb,
+  AVAudioUnitSampler,
+  AVAudioUnitTimePitch,
   AVPlayer,
   AVQueuePlayer,
   AngularGradient,
@@ -5953,6 +6860,7 @@ export {
   ForEach,
   Form,
   Gauge,
+  GenerationError,
   GeometryChangeView,
   GeometryReader,
   GraphicsContext,
@@ -5968,6 +6876,7 @@ export {
   LOADING_INDICATOR_DELAY_MS,
   Label,
   LabeledContent,
+  LanguageModelSession,
   Layout,
   LazyHGrid,
   LazyHStack,
@@ -5991,6 +6900,7 @@ export {
   ProgressView,
   RadialGradient,
   Rectangle,
+  ResponseStream,
   RoundedRectangle,
   Row,
   RuleMark,
@@ -6006,6 +6916,7 @@ export {
   SplitSelectionContext,
   Stepper,
   SwiftUIView,
+  SystemLanguageModel,
   Tab,
   TabView,
   Table,
@@ -6052,6 +6963,7 @@ export {
   moveItems,
   nextGeometry,
   niceStep,
+  noteInName,
   opacity,
   openURL,
   padding,
@@ -6060,8 +6972,10 @@ export {
   providingScrollSettings,
   readBinding,
   rgb,
+  samplerZones,
   scrollGeometryOf,
   shapeStyle,
+  shareParamsOf,
   signInWithApple,
   system,
   takeScrollSettings,
@@ -6069,6 +6983,7 @@ export {
   unitPoint,
   useAVPlayer,
   useAppStorage,
+  useAudioEngine,
   useAudioRecorder,
   useColorScheme,
   useContextBridge,
@@ -6086,6 +7001,7 @@ export {
   useScenePhase,
   useSpeechRecognition,
   useSpeechSynthesis,
+  useSystemLanguageModel,
   useUndoManager,
   useViewEnvironment,
   useWakeLock,