@swiftbrowser/native 0.19.0 → 0.21.0

package/src/fetch.ts

@@ -1,13 +1,15 @@
 /**
  * `fetch`, `Headers`, `Request`, `Response` and `AbortController` over the
- * bridge's `fetch` primitive (`URLSession` on the Swift side). Bodies cross
- * as base64; a `Response` reads them back as text, JSON, bytes or a `Blob`.
- * A `Blob` or `FormData` body (blob.ts) is sent whole, the form as
- * multipart; there are no streams.
+ * bridge's `fetch` primitive (`URLSession` on the Swift side). A request
+ * body is a list of parts (blob.ts): bytes here, or ranges of files on disk
+ * (picked or dropped files, and blobs and forms holding them), which a host
+ * with `fetchStreams` sends as one stream straight from disk, and an older
+ * host is given read into memory. A `Response` reads its body back as
+ * text, JSON, bytes or a `Blob`; responses are not streamed.
  */
 
-import type { NativeBridge, NativeFetchResult } from './bridge';
-import { encodeMultipart, SimpleBlob, SimpleFormData } from './blob';
+import type { NativeBridge, NativeFetchRequest, NativeFetchResult } from './bridge';
+import { encodeMultipart, partsAreLazy, partsBytes, partSize, SimpleBlob, SimpleFormData, type BodyPart } from './blob';
 import { base64Encode, bridgedBytes, utf8Decode, utf8Encode } from './encoding';
 
 type HeadersInitLike = SimpleHeaders | Record<string, string> | [string, string][];
@@ -129,50 +131,51 @@ export function setBodyRandomness(random: (count: number) => Uint8Array): void {
   randomBytes = random;
 }
 
-/** Bytes of a body, and the content type it implies when the caller set none. */
-function encodeBody(body: BodyInitLike): { bytes: Uint8Array | null; contentType: string | null } {
-  if (body === null || body === undefined) return { bytes: null, contentType: null };
-  if (typeof body === 'string') return { bytes: utf8Encode(body), contentType: 'text/plain;charset=UTF-8' };
-  if (body instanceof SimpleBlob) return { bytes: body.bytes(), contentType: body.type || null };
+/** The content type a body implies when the caller set none, and its parts. */
+function encodeBody(body: BodyInitLike): { parts: BodyPart[] | null; contentType: string | null } {
+  if (body === null || body === undefined) return { parts: null, contentType: null };
+  if (typeof body === 'string') return { parts: [{ bytes: utf8Encode(body) }], contentType: 'text/plain;charset=UTF-8' };
+  if (body instanceof SimpleBlob) return { parts: body.parts(), contentType: body.type || null };
   if (body instanceof SimpleFormData) return encodeMultipart(body, randomBytes);
-  if (body instanceof ArrayBuffer) return { bytes: new Uint8Array(body), contentType: null };
-  if (ArrayBuffer.isView(body)) return { bytes: new Uint8Array(body.buffer, body.byteOffset, body.byteLength), contentType: null };
+  if (body instanceof ArrayBuffer) return { parts: [{ bytes: new Uint8Array(body) }], contentType: null };
+  if (ArrayBuffer.isView(body)) return { parts: [{ bytes: new Uint8Array(body.buffer, body.byteOffset, body.byteLength) }], contentType: null };
   if (typeof body === 'object' && Symbol.iterator in body && typeof body.toString === 'function') {
-    return { bytes: utf8Encode(body.toString()), contentType: 'application/x-www-form-urlencoded;charset=UTF-8' };
+    return { parts: [{ bytes: utf8Encode(body.toString()) }], contentType: 'application/x-www-form-urlencoded;charset=UTF-8' };
   }
-  return { bytes: utf8Encode(String(body)), contentType: 'text/plain;charset=UTF-8' };
+  return { parts: [{ bytes: utf8Encode(String(body)) }], contentType: 'text/plain;charset=UTF-8' };
 }
 
 class Body {
-  protected bytes: Uint8Array | null;
+  /** The body's parts: in memory, or on disk until read. */
+  protected parts: BodyPart[] | null;
   bodyUsed = false;
-  constructor(bytes: Uint8Array | null) {
-    this.bytes = bytes;
+  constructor(parts: BodyPart[] | null) {
+    this.parts = parts;
   }
   get body(): null {
     // No streams; read the body whole with the methods below.
     return null;
   }
-  private take(): Uint8Array {
+  private async take(): Promise<Uint8Array> {
     if (this.bodyUsed) throw new TypeError('body used already');
     this.bodyUsed = true;
-    return this.bytes ?? new Uint8Array(0);
+    return this.parts ? partsBytes(this.parts) : new Uint8Array(0);
   }
   async arrayBuffer(): Promise<ArrayBuffer> {
-    const bytes = this.take();
+    const bytes = await this.take();
     return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength) as ArrayBuffer;
   }
   async bytesArray(): Promise<Uint8Array> {
     return this.take();
   }
   async text(): Promise<string> {
-    return utf8Decode(this.take());
+    return utf8Decode(await this.take());
   }
   async json(): Promise<unknown> {
-    return JSON.parse(utf8Decode(this.take()));
+    return JSON.parse(utf8Decode(await this.take()));
   }
   async blob(): Promise<SimpleBlob> {
-    return new SimpleBlob([this.take()], { type: this.contentType() });
+    return new SimpleBlob([await this.take()], { type: this.contentType() });
   }
   /** The body's content type, for `blob()`; a Request or Response reads its headers. */
   protected contentType(): string {
@@ -196,24 +199,28 @@ export class SimpleRequest extends Body {
 
   constructor(input: string | SimpleRequest | { href: string }, init: RequestInitLike = {}) {
     const base = input instanceof SimpleRequest ? input : null;
-    const { bytes, contentType } = encodeBody(init.body);
-    super(bytes ?? base?.rawBytes() ?? null);
+    const { parts, contentType } = encodeBody(init.body);
+    super(parts ?? base?.rawBody() ?? null);
     this.url = typeof input === 'string' ? input : input instanceof SimpleRequest ? input.url : input.href;
     this.method = (init.method ?? base?.method ?? 'GET').toUpperCase();
     this.headers = new SimpleHeaders(init.headers ?? base?.headers);
     if (contentType && !this.headers.has('content-type')) this.headers.set('content-type', contentType);
     this.signal = init.signal ?? base?.signal ?? new SimpleAbortSignal();
   }
-  /** @internal */
-  rawBytes(): Uint8Array | null {
-    return this.bytes;
+  /** @internal The body's bytes, read from disk first where they come from there. */
+  async rawBytes(): Promise<Uint8Array | null> {
+    return this.parts === null ? null : await partsBytes(this.parts);
+  }
+  /** @internal The body's parts. */
+  rawBody(): BodyPart[] | null {
+    return this.parts;
   }
   protected override contentType(): string {
     return this.headers.get('content-type') ?? '';
   }
 
   clone(): SimpleRequest {
-    return new SimpleRequest(this, { body: this.bytes });
+    return new SimpleRequest(this, {});
   }
 }
 
@@ -233,8 +240,8 @@ export class SimpleResponse extends Body {
   readonly redirected = false;
 
   constructor(body: BodyInitLike = null, init: ResponseInitLike = {}) {
-    const { bytes, contentType } = encodeBody(body);
-    super(bytes);
+    const { parts, contentType } = encodeBody(body);
+    super(parts);
     this.status = init.status ?? 200;
     this.statusText = init.statusText ?? '';
     this.headers = new SimpleHeaders(init.headers);
@@ -249,7 +256,9 @@ export class SimpleResponse extends Body {
   }
 
   clone(): SimpleResponse {
-    return new SimpleResponse(this.bytes, { status: this.status, statusText: this.statusText, headers: this.headers, url: this.url });
+    const copy = new SimpleResponse(null, { status: this.status, statusText: this.statusText, headers: this.headers, url: this.url });
+    copy.parts = this.parts;
+    return copy;
   }
   static json(data: unknown, init: ResponseInitLike = {}): SimpleResponse {
     const response = new SimpleResponse(JSON.stringify(data), init);
@@ -261,6 +270,22 @@ export class SimpleResponse extends Body {
   }
 }
 
+/** In-memory parts as one array (none is on disk); one part is itself. */
+function joinBytes(parts: readonly BodyPart[]): Uint8Array {
+  const [only] = parts;
+  if (parts.length === 1 && only && 'bytes' in only) return only.bytes;
+  const total = parts.reduce((sum, part) => sum + partSize(part), 0);
+  const out = new Uint8Array(total);
+  let at = 0;
+  for (const part of parts) {
+    if ('bytes' in part) {
+      out.set(part.bytes, at);
+      at += part.bytes.byteLength;
+    }
+  }
+  return out;
+}
+
 export interface FetchGlobals {
   fetch: (input: string | SimpleRequest | { href: string }, init?: RequestInitLike) => Promise<SimpleResponse>;
   Headers: typeof SimpleHeaders;
@@ -275,9 +300,11 @@ export interface FetchGlobals {
 /**
  * The fetch globals over the bridge. With `bytes` (a host that carries
  * typed arrays, docs/notes/bytes.md) bodies cross as views beside the JSON
- * both ways; without, as base64.
+ * both ways; without, as base64. With `streams` (the host `fetchStreams()`,
+ * which needs `bytes`) a body holding files on disk goes as parts the host
+ * streams from there; without, such a body is read into memory first.
  */
-export function createFetch(native: Pick<NativeBridge, 'fetch'>, options: { bytes?: boolean } = {}): FetchGlobals {
+export function createFetch(native: Pick<NativeBridge, 'fetch' | 'fetchCancel'>, options: { bytes?: boolean; streams?: boolean } = {}): FetchGlobals {
   let nextId = 1;
   const pending = new Map<number, { resolve: (response: SimpleResponse) => void; reject: (error: unknown) => void }>();
 
@@ -290,16 +317,47 @@ export function createFetch(native: Pick<NativeBridge, 'fetch'>, options: { byte
       }
       const id = nextId++;
       pending.set(id, { resolve, reject });
+      let sent = false;
       request.signal.addEventListener('abort', () => {
-        if (pending.delete(id)) reject(request.signal.reason);
+        if (!pending.delete(id)) return;
+        // The host stops the task where it can (0.20); an older host finishes it and its answer is ignored.
+        if (sent) native.fetchCancel?.(id);
+        reject(request.signal.reason);
       });
-      const bytes = request.rawBytes();
       const head = { url: request.url, method: request.method, headers: request.headers.toObject() };
-      if (options.bytes) {
-        if (bytes) native.fetch(id, { ...head, body: { $bytes: 0 }, bytes: true }, bytes);
-        else native.fetch(id, { ...head, body: null, bytes: true });
+      const send = (bytes: Uint8Array | null): void => {
+        if (!pending.has(id)) return; // aborted while the body was read
+        sent = true;
+        if (options.bytes) {
+          if (bytes) native.fetch(id, { ...head, body: { $bytes: 0 }, bytes: true }, bytes);
+          else native.fetch(id, { ...head, body: null, bytes: true });
+        } else {
+          native.fetch(id, { ...head, body: bytes ? base64Encode(bytes) : null });
+        }
+      };
+      const parts = request.rawBody();
+      if (parts === null || !partsAreLazy(parts)) {
+        // Bytes already here go out in this turn (tests and callers see the request at once).
+        send(parts === null ? null : joinBytes(parts));
+      } else if (options.streams && options.bytes) {
+        // Files on disk stay there: the host streams the parts in order, their total length known.
+        sent = true;
+        const views: Uint8Array[] = [];
+        const bodyParts: NonNullable<NativeFetchRequest['bodyParts']> = parts.map((part) => {
+          if ('bytes' in part) {
+            views.push(part.bytes);
+            return { $bytes: views.length - 1 };
+          }
+          return { url: part.file.url, start: part.file.start, end: part.file.end };
+        });
+        const headers = { ...head.headers };
+        if (!('content-length' in headers)) headers['content-length'] = String(parts.reduce((sum, part) => sum + partSize(part), 0));
+        native.fetch(id, { ...head, headers, body: null, bodyParts, bytes: true }, ...views);
       } else {
-        native.fetch(id, { ...head, body: bytes ? base64Encode(bytes) : null });
+        // An older host: the files are read here first.
+        partsBytes(parts).then(send, (error: unknown) => {
+          if (pending.delete(id)) reject(error instanceof Error ? error : new TypeError(`fetch failed: ${String(error)}`));
+        });
       }
     });
   };

package/src/hostRequests.ts

@@ -25,7 +25,7 @@
  * the standard directories from the bridge's `appDirectories()`.
  */
 
-import { objectURL, SimpleBlob, SimpleFile } from './blob';
+import { blobBytes, LazyFile, objectURL, SimpleBlob, SimpleFile } from './blob';
 import type { NativeBridge } from './bridge';
 import { base64Encode, bridgedBytes } from './encoding';
 import { nativeUndoHost } from './undo';
@@ -36,7 +36,9 @@ export type HostRequestBridge = Required<Pick<NativeBridge, 'hostRequest'>> & Pi
 export interface BridgedFile {
   name: string;
   type: string;
-  data: string | Uint8Array;
+  /** The bytes; absent when the file is still on disk, named by `url`. */
+  data?: string | Uint8Array;
+  url?: string;
 }
 
 export interface WebAuthenticateOptions {
@@ -131,12 +133,33 @@ export function resetHostRequests(): void {
 }
 
 async function bridgedFile(file: SimpleBlob & { name?: string }): Promise<BridgedFile> {
-  return { name: file.name ?? 'file', type: file.type, data: file.bytes() };
+  // A picked file still on disk goes as its URL: the host reads it itself.
+  if (file instanceof LazyFile && file.isWhole) return { name: file.name ?? 'file', type: file.type, url: file.url };
+  return { name: file.name ?? 'file', type: file.type, data: await blobBytes(file) };
+}
+
+/** A file as a host answers it: bytes in place (`data`), or still on disk (`url`, `size`), read on demand through the files bridge. */
+interface AnsweredFile {
+  name: string;
+  type: string;
+  data?: string | Uint8Array;
+  url?: string;
+  size?: number;
+  lastModified?: number;
+}
+
+/** Reads a range of a file on disk through the files bridge (FilesBridge.swift `readRange`). */
+async function readFileRange(url: string, start: number, end: number): Promise<Uint8Array> {
+  return bridgedBytes((await hostRequest<{ data?: string | Uint8Array }>('files', { action: 'readRange', url, start, end }))?.data ?? '');
 }
 
 function filesOf(value: unknown): SimpleFile[] {
-  const files = (value as { files?: BridgedFile[] } | undefined)?.files ?? [];
-  return files.map((file) => new SimpleFile([bridgedBytes(file.data)], file.name, { type: file.type }));
+  const files = (value as { files?: AnsweredFile[] } | undefined)?.files ?? [];
+  return files.map((file) => {
+    const options = { type: file.type, ...(typeof file.lastModified === 'number' ? { lastModified: file.lastModified } : {}) };
+    if (file.data === undefined && typeof file.url === 'string') return LazyFile.make(file.url, file.name, file.size ?? 0, readFileRange, options);
+    return new SimpleFile([bridgedBytes(file.data ?? '')], file.name, options);
+  });
 }
 
 /**
@@ -205,7 +228,21 @@ function nativeFiles(directories: FileDirectories): Record<string, unknown> {
       return () => void fileWatchers.delete(listener);
     },
     read: async (url: string): Promise<Uint8Array> => bridgedBytes((await files<{ data?: string | Uint8Array }>({ action: 'read', url }))?.data ?? ''),
-    write: (url: string, data: Uint8Array): Promise<void> => files({ action: 'write', url, data }).then(() => undefined),
+    // A range read through `FileHandle`, so a large file is read a piece at a time (FilesBridge.swift `readRange`).
+    readRange: async (url: string, start: number, end: number): Promise<Uint8Array> =>
+      bridgedBytes((await files<{ data?: string | Uint8Array }>({ action: 'readRange', url, start, end }))?.data ?? ''),
+    // A file the viewer picked or dropped (a `LazyFile`, still on disk) is copied there by the host (`importItem`); other bytes cross the bridge.
+    write: async (url: string, data: Uint8Array | SimpleBlob): Promise<void> => {
+      if (data instanceof LazyFile) {
+        if (data.isWhole) {
+          await files({ action: 'importItem', from: data.url, to: url });
+          return;
+        }
+        await files({ action: 'write', url, data: await data.bytesAsync() });
+        return;
+      }
+      await files({ action: 'write', url, data: data instanceof SimpleBlob ? data.bytes() : data });
+    },
     remove: (url: string): Promise<void> => files({ action: 'remove', url }).then(() => undefined),
     createDirectory: (url: string): Promise<void> => files({ action: 'createDirectory', url }).then(() => undefined),
     list: async (url: string): Promise<string[]> => (await files<{ urls?: string[] }>({ action: 'list', url }))?.urls ?? [],
@@ -235,6 +272,9 @@ export function nativeHostEnvironment(): Record<string, unknown> {
   const directories = appDirectories();
   return {
     ...(directories ? { files: nativeFiles(directories) } : {}),
+    // A file dropped on the app, left on disk by the host (Drawing.swift's drop destination): a `LazyFile` read by range.
+    fileFromReference: (item: { type: string; name?: string; path?: string; url: string; size?: number }): SimpleFile =>
+      LazyFile.make(item.url, item.path ?? item.name ?? 'file', item.size ?? 0, readFileRange, { type: item.type }),
     share: async (data: { title?: string; text?: string; url?: string; files?: SimpleFile[] }): Promise<void> => {
       const params: Record<string, unknown> = {};
       if (data.title) params['title'] = data.title;
@@ -250,6 +290,19 @@ export function nativeHostEnvironment(): Record<string, unknown> {
     },
     canShare: () => true,
     download: (blob: SimpleBlob, filename: string): void => {
+      // A picked file still on disk goes by URL (the host copies it); bytes go in the same turn.
+      const file = blob instanceof LazyFile && blob.isWhole ? { name: filename, type: blob.type, url: blob.url } : null;
+      if (file) {
+        void hostRequest('share', { files: [file] }).catch(() => undefined);
+        return;
+      }
+      if (blob instanceof LazyFile) {
+        void blob
+          .bytesAsync()
+          .then((data) => hostRequest('share', { files: [{ name: filename, type: blob.type, data }] }))
+          .catch(() => undefined);
+        return;
+      }
       void hostRequest('share', { files: [{ name: filename, type: blob.type, data: blob.bytes() }] }).catch(() => undefined);
     },
     pickFiles: async (options: { accept: string; multiple: boolean }): Promise<SimpleFile[]> =>
@@ -259,12 +312,13 @@ export function nativeHostEnvironment(): Record<string, unknown> {
       const result = await hostRequest<{ outcome?: string; urls?: string[] } | null>('exportFiles', { files: await Promise.all(files.map(bridgedFile)) });
       return { outcome: result?.outcome ?? 'cancelled', ...(result?.urls ? { urls: result.urls } : {}) };
     },
-    objectURL: (file: SimpleBlob): string => objectURL(file),
+    // A picked file still on disk is its own URL (the image loader and AVPlayer read files); bytes become a `data:` URL.
+    objectURL: (file: SimpleBlob): string => (file instanceof LazyFile && file.isWhole ? file.url : objectURL(file)),
     clipboard: {
       writeText: (text: string): Promise<void> => hostRequest('clipboard', { action: 'write', text }).then(() => undefined),
       writeImage: async (png: Promise<SimpleBlob>): Promise<void> => {
         const file = await png;
-        await hostRequest('clipboard', { action: 'write', files: [{ name: 'image.png', type: file.type || 'image/png', data: file.bytes() }] });
+        await hostRequest('clipboard', { action: 'write', files: [{ name: 'image.png', type: file.type || 'image/png', data: await blobBytes(file) }] });
       },
       readText: async (): Promise<string> => (await hostRequest<{ text?: string }>('clipboard', { action: 'readText' }))?.text ?? '',
     },

package/src/index.ts

@@ -12,13 +12,12 @@
  */
 
 export { run, type RunOptions, type Running } from './run';
-export { Native, type NativeProps } from './native';
 export { callNative, callNativeSync, nativeFunctions, hasNativeFunction, onNativeEvent } from './nativeFunctions';
 export { installRuntime, type InstallOptions } from './runtime';
 export { nativeBridge, launchArguments, type NativeBridge, type NativeFetchRequest, type NativeFetchResult, type WorkerEngine } from './bridge';
 export { SimpleHeaders, SimpleRequest, SimpleResponse, SimpleAbortController, SimpleAbortSignal, createFetch } from './fetch';
 export { SimpleURL, SimpleURLSearchParams } from './url';
-export { SimpleBlob, SimpleFile, SimpleFormData, encodeMultipart, objectURL } from './blob';
+export { LazyFile, SimpleBlob, SimpleFile, SimpleFormData, blobBytes, encodeMultipart, encodeMultipartAsync, objectURL, partsBytes, type BodyPart } from './blob';
 export { NativeWebSocket, type NativeWebSocketEvent } from './webSocket';
 export { createSubtleCrypto } from './subtle';
 export { matchMedia, updateMediaEnvironment, type MediaEnvironment } from './matchMedia';

package/src/runtime.ts

@@ -190,7 +190,7 @@ export function installRuntime(native: NativeBridge, target: AnyGlobal = globalT
   const carriesBytes = typeof native.hostRequestBytes === 'function';
   // UTF-8 on the host past a few dozen characters (encoding.ts).
   installNativeUTF8(native.decodeUTF8 && native.encodeUTF8 ? { decode: native.decodeUTF8.bind(native), encode: native.encodeUTF8.bind(native) } : null);
-  const fetchGlobals = createFetch(native, { bytes: carriesBytes });
+  const fetchGlobals = createFetch(native, { bytes: carriesBytes, streams: carriesBytes && native.fetchStreams?.() === true });
   define('fetch', fetchGlobals.fetch);
   define('Headers', fetchGlobals.Headers);
   define('Request', fetchGlobals.Request);

package/src/webSocket.ts

@@ -9,7 +9,7 @@
  * `binaryType` (`blob` by default, or `arraybuffer`).
  */
 
-import { SimpleBlob } from './blob';
+import { blobBytes, LazyFile, SimpleBlob } from './blob';
 import type { NativeBridge } from './bridge';
 import { base64Encode, bridgedBytes } from './encoding';
 
@@ -92,6 +92,15 @@ export class NativeWebSocket {
       bridge?.wsSend(this.id, JSON.stringify({ text: data }));
       return;
     }
+    if (data instanceof LazyFile) {
+      // A picked file on disk: read it, then send (the frame goes out when the read lands; order among lazy sends is the reads').
+      void blobBytes(data).then((bytes) => {
+        if (this.readyState !== NativeWebSocket.OPEN) return;
+        if (carriesBytes) bridge?.wsSend(this.id, JSON.stringify({ binary: { $bytes: 0 } }), bytes);
+        else bridge?.wsSend(this.id, JSON.stringify({ binary: base64Encode(bytes) }));
+      });
+      return;
+    }
     const bytes =
       data instanceof SimpleBlob
         ? data.bytes()

package/swift/Packages/SwiftBrowserDSP/Sources/SwiftBrowserDSP/ProgramNode.swift

@@ -18,9 +18,11 @@ import SwiftBrowserProtocol
 /// ```
 @MainActor
 public enum SwiftBrowserDSP {
-    /// Registers the `program` kind with SwiftBrowserNative's audio engine; call at launch, before the bundle loads.
+    /// Registers the `program` kind with SwiftBrowserNative's audio engine, and `ScopeView`'s SwiftUI view; call at
+    /// launch, before the bundle loads.
     public static func install() {
         AudioEngineNodes.register("program") { context in ProgramNode(format: context.format) }
+        ViewRegistry.register("SwiftBrowserDSP.scope") { context in DSPScopeView(props: context.props) }
     }
 }
 
@@ -37,6 +39,8 @@ final class ProgramNode: AudioEngineCustomNode {
     private var program: DSPProgram?
     /// Every parameter the app set, by name: a program loaded later takes the values it has names for.
     private var values: [String: Float] = [:]
+    /// The transport's tempo as last set, for a program loaded later.
+    private var tempo: Double = 120
 
     init(format: AVAudioFormat) {
         sampleRate = format.sampleRate
@@ -50,13 +54,15 @@ final class ProgramNode: AudioEngineCustomNode {
             let buffers = UnsafeMutableAudioBufferListPointer(list)
             guard let first = buffers.first?.mData?.assumingMemoryBound(to: Float.self) else { return noErr }
             let count = Int(frames)
-            if !renderer.render(into: first, frames: count) {
+            // Two channels or more: the left side, then the right; one: their average.
+            let second = buffers.count > 1 ? buffers[1].mData?.assumingMemoryBound(to: Float.self) : nil
+            if !renderer.render(into: first, right: second, frames: count) {
                 silence.pointee = true
                 for buffer in buffers { buffer.mData?.initializeMemory(as: Float.self, repeating: 0, count: count) }
                 return noErr
             }
-            for buffer in buffers.dropFirst() {
-                buffer.mData?.assumingMemoryBound(to: Float.self).update(from: first, count: count)
+            for buffer in buffers.dropFirst(2) {
+                buffer.mData?.initializeMemory(as: Float.self, repeating: 0, count: count)
             }
             return noErr
         }
@@ -64,6 +70,12 @@ final class ProgramNode: AudioEngineCustomNode {
 
     func set(_ key: String, _ value: JSONValue) throws -> Bool {
         defer { renderer.collect() }
+        if key == "view" {
+            // What a view finds the node's frames by.
+            guard let token = value.string else { throw ProgramNodeError("unsupported: view takes a string") }
+            ScopeTaps.register(token, renderer.tap)
+            return true
+        }
         if key == "program" {
             guard let json = value.string else { throw DSPProgramError("a program crosses as JSON") }
             let program = try DSPProgram(json: json)
@@ -72,10 +84,21 @@ final class ProgramNode: AudioEngineCustomNode {
             for (name, value) in values {
                 if let index = machine.parameterIndex(name) { machine.setParameter(at: index, value) }
             }
+            machine.setTempo(tempo)
             self.program = program
             renderer.replace(machine)
             return true
         }
+        if key == "tempo" || key == "beat" {
+            guard let number = value.double else { throw ProgramNodeError("unsupported: \(key) takes a number") }
+            if key == "tempo" {
+                tempo = number
+                renderer.send(.tempo(number))
+            } else {
+                renderer.send(.seek(number))
+            }
+            return true
+        }
         if key.hasPrefix("param.") {
             guard let number = value.double else { throw ProgramNodeError("unsupported: \(key) takes a number") }
             let name = String(key.dropFirst(6))
@@ -91,11 +114,13 @@ final class ProgramNode: AudioEngineCustomNode {
     func note(_ action: String, _ params: JSONObject) throws -> Bool {
         defer { renderer.collect() }
         let int = { (key: String) in Int32(truncatingIfNeeded: params.int(key) ?? 0) }
+        // When on the program's transport, for a command that says.
+        let beat = params.double("beat")
         switch action {
-        case "startNote": renderer.send(.noteOn(int("note"), int("velocity")))
-        case "stopNote": renderer.send(.noteOff(int("note")))
-        case "controller": renderer.send(.controller(int("controller"), int("value")))
-        case "pitchBend": renderer.send(.pitchBend(Int32(truncatingIfNeeded: params.int("value") ?? 8192)))
+        case "startNote": renderer.send(.noteOn(int("note"), int("velocity"), beat))
+        case "stopNote": renderer.send(.noteOff(int("note"), beat))
+        case "controller": renderer.send(.controller(int("controller"), int("value"), beat))
+        case "pitchBend": renderer.send(.pitchBend(Int32(truncatingIfNeeded: params.int("value") ?? 8192), beat))
         default: return false
         }
         return true
@@ -115,11 +140,13 @@ struct ProgramNodeError: Error, CustomStringConvertible {
 
 /// What the main actor sends the audio thread.
 enum ProgramEvent: Sendable {
-    case noteOn(Int32, Int32)
-    case noteOff(Int32)
-    case controller(Int32, Int32)
-    case pitchBend(Int32)
+    case noteOn(Int32, Int32, Double?)
+    case noteOff(Int32, Double?)
+    case controller(Int32, Int32, Double?)
+    case pitchBend(Int32, Double?)
     case parameter(Int32, Float)
+    case tempo(Double)
+    case seek(Double)
     case reset
 }
 
@@ -137,6 +164,8 @@ final class Renderer: @unchecked Sendable {
     }
 
     private let lock = OSAllocatedUnfairLock(initialState: Shared())
+    /// The frames rendered last, for views.
+    let tap = ScopeTap()
     // The audio thread's own.
     private var machine: DSPMachine?
     private var inbox: [ProgramEvent] = []
@@ -171,10 +200,12 @@ final class Renderer: @unchecked Sendable {
         _ = retired
     }
 
-    /// The audio thread: false when there is no program yet (silence).
-    func render(into out: UnsafeMutablePointer<Float>, frames: Int) -> Bool {
+    /// The audio thread: false when there is no program yet (silence). With `right`, the left side into `out`.
+    func render(into out: UnsafeMutablePointer<Float>, right: UnsafeMutablePointer<Float>? = nil, frames: Int) -> Bool {
         _ = lock.withLockIfAvailableUnchecked { shared in
             if let next = shared.machine, shared.retired == nil {
+                // The transport carries on through a new program.
+                if let machine { next.seek(toBeat: machine.position) }
                 shared.retired = machine
                 machine = next
                 shared.machine = nil
@@ -187,17 +218,89 @@ final class Renderer: @unchecked Sendable {
         }
         for event in inbox {
             switch event {
-            case let .noteOn(note, velocity): machine.noteOn(note, velocity: velocity)
-            case let .noteOff(note): machine.noteOff(note)
-            case let .controller(number, value): machine.controller(number, value: value)
-            case let .pitchBend(value): machine.pitchBend(value)
+            case let .noteOn(note, velocity, beat): machine.noteOn(note, velocity: velocity, atBeat: beat)
+            case let .noteOff(note, beat): machine.noteOff(note, atBeat: beat)
+            case let .controller(number, value, beat): machine.controller(number, value: value, atBeat: beat)
+            case let .pitchBend(value, beat): machine.pitchBend(value, atBeat: beat)
             case let .parameter(index, value): machine.setParameter(at: Int(index), value)
+            case let .tempo(bpm): machine.setTempo(bpm)
+            case let .seek(beat): machine.seek(toBeat: beat)
             case .reset: machine.reset()
             }
         }
         inbox.removeAll(keepingCapacity: true)
-        machine.render(into: out, frames: frames)
+        if let right {
+            machine.render(left: out, right: right, frames: frames)
+        } else {
+            machine.render(into: out, frames: frames)
+        }
+        tap.write(out, right, frames: frames)
         return true
     }
 }
+
+/// A node's last 2048 frames, its two sides mixed, for views (`DSPScopeView`): the audio thread writes them when the
+/// lock is free (never waiting, and a frame a view misses is only a frame), a view copies the newest out.
+final class ScopeTap: @unchecked Sendable {
+    static let capacity = 2048
+    /// Frames written so far; the samples are only touched under it.
+    private let lock = OSAllocatedUnfairLock(initialState: 0)
+    private let samples: UnsafeMutablePointer<Float>
+
+    init() {
+        samples = .allocate(capacity: Self.capacity)
+        samples.initialize(repeating: 0, count: Self.capacity)
+    }
+
+    deinit {
+        samples.deallocate()
+    }
+
+    /// The audio thread.
+    func write(_ left: UnsafePointer<Float>, _ right: UnsafePointer<Float>?, frames: Int) {
+        let samples = samples
+        _ = lock.withLockIfAvailableUnchecked { written in
+            let mask = Self.capacity - 1
+            if let right {
+                for i in 0..<frames { samples[(written + i) & mask] = (left[i] + right[i]) * 0.5 }
+            } else {
+                for i in 0..<frames { samples[(written + i) & mask] = left[i] }
+            }
+            written += frames
+        }
+    }
+
+    /// The newest `buffer.count` frames (at most 2048), oldest first.
+    func read(into buffer: inout [Float]) {
+        let count = Swift.min(buffer.count, Self.capacity)
+        let samples = samples
+        buffer.withUnsafeMutableBufferPointer { out in
+            lock.withLockUnchecked { written in
+                let mask = Self.capacity - 1
+                for i in 0..<count { out[i] = samples[(written - count + i) & mask] }
+            }
+        }
+    }
+}
+
+/// The program nodes' taps by view token, for views made before or after the node.
+enum ScopeTaps {
+    private struct Weak {
+        weak var tap: ScopeTap?
+    }
+
+    private static let lock = OSAllocatedUnfairLock(initialState: [String: Weak]())
+
+    static func register(_ token: String, _ tap: ScopeTap) {
+        lock.withLockUnchecked { taps in
+            taps = taps.filter { $0.value.tap != nil }
+            taps[token] = Weak(tap: tap)
+        }
+    }
+
+    static func tap(_ token: String) -> ScopeTap? {
+        lock.withLockUnchecked { $0[token]?.tap }
+    }
+}
 #endif
+