@ksp-gonogo/kerbcast 1.6.3 → 1.8.0

package/CHANGELOG.md

@@ -1,5 +1,66 @@
 # Changelog
 
+## Unreleased (next minor)
+
+Client-side camera recording (pure SDK; no sidecar/plugin/protocol change).
+
+### Added
+
+- `KerbcastClient.recording`: a `RecordingController` that records a camera's
+  already-received WebRTC track with the browser's `MediaRecorder`, entirely
+  client-local (the sidecar never learns a recording happened)
+- Per-feed API: `startRecording(flightId, opts?)` returns a client-minted
+  `recordingId`; `stopRecording(recordingId)` resolves a `RecordingHandle`;
+  `fetchRecording` / `discardRecording` / `isRecording`
+- `RecordingHandle = { recordingId, blob, mimeType, utStart?, utEnd?,
+  utSamples, byteSize, durationMs }`, where `utSamples` is a ~1Hz
+  (recording-time, UT) series so a consumer can interpolate any frame's
+  mission-time near-frame-tight; out of flight it falls back to wall-clock
+  timing (`ut` absent) and upgrades automatically once UT appears
+- Mime negotiation prefers `video/mp4;codecs=avc1` where
+  `MediaRecorder.isTypeSupported`, else `video/webm;codecs=vp9`, else
+  `video/webm`; the chosen type is on the handle. `opts.maxDurationMs` auto-stops
+- Grouped API: `startGroupedRecording(flightIds, opts?)` (all recorders open in
+  one tick) and `stopGroupedRecording(groupId, { targetUt? })`. `targetUt`
+  enforces a coverage guarantee: finalization waits until every feed's latest
+  UT sample passes it, so no feed falls short of the common window
+- `GroupedRecordingHandle = { groupId, recordings, commonUtWindow? }`, where
+  `commonUtWindow` is the intersection of the feeds' `[utStart, utEnd]`
+- Grouped clips are physically remux-trimmed to `commonUtWindow` by default
+  (keyframe-boundary cut, no re-encode) via a lazily `import()`-ed Mediabunny,
+  loaded only on grouped-record start (single recordings stay dependency-free);
+  a clip that can't be cut cleanly (webm, or a remux error) degrades to
+  metadata-only and never fails the recording. `utSamples` + `commonUtWindow`
+  still ride along after trimming so a consumer can align to telemetry
+- Helpers `negotiateMimeType`, `commonUtWindow`, `utToRecordingTimeMs`
+- `StubMediaRecorder`: a jsdom `MediaRecorder` shim installed by
+  `installDomStubs`, so the full record -> UT-sample -> stop -> handle path is
+  headless-testable (its `isTypeSupported` is controllable for mime tests)
+- `mediabunny` as a dependency, dynamically imported for grouped-clip trimming
+  only (never pulled by single recordings or non-recording consumers)
+
+## 1.7.0 - 2026-07-24
+
+Crew face cameras, auto-resolution, and camera targeting.
+
+### Added
+
+- `KerbcastClient.reportDisplaySize(flightId, width, height)`: report a
+  consumer's own displayed pixel size for a camera. The sidecar aggregates it
+  MAX-across-consumers to drive auto-resolution (distinct from `setRenderSize`,
+  which is the shared operator cap).
+- `KerbcastClient.setTrackTarget(flightId, mode)`: ask a pan+zoom camera to
+  auto-track a moving vessel, or stop.
+- `TrackMode` type (`"none" | "activeVessel" | "target"`).
+- `trackMode?: TrackMode` on `CameraState` (WS push) and `CameraInfo`
+  (`GET /cameras`), server-authoritative so every consumer reflects the same
+  tracking state.
+- `MockSidecar` accepts the new `report-display-size` and `set-track-target`
+  client messages (records them; `report-display-size` is advisory and does not
+  mutate render dims).
+- `MockCameraInit` gains `kind`, `crewLocation`, `kerbalPersistentId`, and
+  `trackMode` for building crew and tracking fixtures.
+
 ## 0.12.0 - 2026-06-07
 
 ### Added

package/README.md

@@ -106,6 +106,22 @@ controls each part actually supports.
   skip, producing the macroblocking and stuttering aesthetic of
   in-game CommNet signal loss. Also a real CPU optimisation when
   every consumer wants degraded video.
+- `kind` (`"part"` | `"kerbal"`) and, for a kerbal face camera,
+  `crewLocation` (`"seat"` | `"eva"`). Distinguish crew face cameras
+  from part cameras.
+- `trackMode` (`"none"` | `"activeVessel"` | `"target"`). Server-authoritative
+  auto-track state on a pan+zoom camera, so every consumer reflects the same
+  tracking state.
+
+## Auto-resolution and targeting
+
+- `client.reportDisplaySize(flightId, width, height)`. Report a consumer's
+  displayed pixel size for a camera; the sidecar takes the MAX across consumers
+  to size the encode (distinct from `setRenderSize`, the shared operator cap).
+  The react feed primitives self-measure and call this for you.
+- `client.setTrackTarget(flightId, mode)`. Ask a pan+zoom camera to auto-track
+  the active vessel or its target (`TrackMode`), or `"none"` to stop. The
+  chosen mode is published back on `CameraState.trackMode`.
 
 ## Pan/zoom input helper
 

package/dist/__generated__/types.d.ts

@@ -14,6 +14,34 @@ export declare enum CameraLifecycle {
     Active = "active",
     Destroyed = "destroyed"
 }
+/**
+ * Distinguishes an existing Hullcam part camera (`Part`) from a
+ * per-kerbal face camera (`Kerbal`).
+ */
+export declare enum CameraKind {
+    Part = "part",
+    Kerbal = "kerbal"
+}
+/**
+ * Which source a kerbal camera is currently rendering: a seated IVA
+ * portrait, or the kerbal's own view while on EVA. Only meaningful when
+ * `CameraState.kind == Kerbal`.
+ */
+export declare enum CrewLocation {
+    Seat = "seat",
+    Eva = "eva"
+}
+/**
+ * Which moving thing a pan+zoom camera should auto-aim at. `None` = tracking
+ * off (manual pan resumes). `ActiveVessel` and `Target` resolve to a world
+ * position from `FlightGlobals` (the active vessel, or its target) with no
+ * orbit math. Only surfaces on cameras with BOTH pan and zoom.
+ */
+export declare enum TrackMode {
+    None = "none",
+    ActiveVessel = "activeVessel",
+    Target = "target"
+}
 /**
  * Layer mask. Mirrors `Kerbcast.CameraLayers` on the plugin side.
  * Receiving clients use this for both the rendered-layer status reports
@@ -62,6 +90,29 @@ export interface CameraState {
      * surface a "SIGNAL LOST" overlay and keep the last frame visible.
      */
     lifecycle?: CameraLifecycle;
+    /**
+     * Whether this is a Hullcam part camera or a per-kerbal face camera.
+     * Defaults to `Part` so existing payloads are unaffected.
+     */
+    kind?: CameraKind;
+    /**
+     * The kerbal's real `ProtoCrewMember.persistentID`: the stable key a
+     * consumer correlates against. `None` for part cameras. Distinct from
+     * `flight_id`, which identifies the camera instance, not the kerbal.
+     */
+    kerbalPersistentId?: number;
+    /**
+     * Which source a kerbal camera is currently rendering. `None` for
+     * part cameras.
+     */
+    crewLocation?: CrewLocation;
+    /**
+     * Server-authoritative auto-track state for a pan+zoom camera (the
+     * operator's persistent intent). `None` (the default) = not tracking.
+     * Every browser reflects this; a browser track overrides a kOS aim on the
+     * same camera (send `SetTrackTarget` with `none` to hand back to kOS).
+     */
+    trackMode?: TrackMode;
     partName: string;
     partTitle: string;
     cameraName: string;
@@ -175,6 +226,19 @@ export interface HelloPayload {
     sidecarVersion: string;
     encoderBackend: string;
 }
+/**
+ * A consumer reporting its OWN current display size in px for one camera.
+ * Unlike `SetRenderSizePayload` (an operator command that sets the shared
+ * render size directly, last-writer-wins), this is a per-consumer input the
+ * sidecar aggregates MAX-across-consumers to drive auto-resolution
+ * (meet-the-minimum-need). Shape mirrors `SetRenderSizePayload`; `width` and
+ * `height` are the consumer's display px for this feed.
+ */
+export interface ReportDisplaySizePayload {
+    flightId: number;
+    width: number;
+    height: number;
+}
 /**
  * Scene-state change: whether KSP is currently in a flight scene. Sent
  * after `Hello` (priming) and whenever the polled in-flight flag flips,
@@ -196,6 +260,17 @@ export interface SetDegradePayload {
      */
     level: number;
 }
+/**
+ * Forces a camera to render at the operator ceiling regardless of
+ * display-size demand. Per-viewer, OR-aggregated by the sidecar: a feed
+ * stays forced while any connected viewer forces it, and releases when
+ * the last one clears it (or disconnects). Still yields to the adaptive
+ * framerate shed; overrides only the demand term.
+ */
+export interface SetForceFullResolutionPayload {
+    flightId: number;
+    force: boolean;
+}
 export interface SetFovPayload {
     flightId: number;
     fov: number;
@@ -248,6 +323,21 @@ export interface SetThrottleMainScreenPayload {
      */
     enabled: boolean;
 }
+/**
+ * Ask a pan+zoom camera to auto-track a moving vessel (or stop). Mirrors
+ * `SetRenderSizePayload` in shape. Server-authoritative: the sidecar holds the
+ * chosen mode per camera and publishes it in `CameraState.track_mode`, so
+ * every browser reflects the same tracking state (never optimistic-local).
+ *
+ * Precedence note (for operators): a browser track OVERRIDES a kOS aim on the
+ * same camera; set `mode: none` to hand aiming back to kOS. While tracking, the
+ * camera also AUTO-ZOOMS to keep the target framed (distance-driven), owning the
+ * zoom over any manual FoV; `mode: none` restores manual zoom untouched.
+ */
+export interface SetTrackTargetPayload {
+    flightId: number;
+    mode: TrackMode;
+}
 export interface SetZoomRatePayload {
     flightId: number;
     /**
@@ -324,13 +414,50 @@ export type ClientMessage =
     content: SetLayersPayload;
 }
 /**
- * Override the operator render size for one camera. Even pixels
- * only (H.264 chroma); server caps at the ring's allocated max.
+ * Cap the auto-resolution for one camera. As of Stage 6 this is a
+ * CEILING on the demand-driven size (effective = min(auto max-across-
+ * consumers, this cap)), NOT an authoritative set: it cannot force a
+ * camera larger than current consumers report, only smaller. Even
+ * pixels only (H.264 chroma); server caps at the ring's allocated max.
  */
  | {
     type: "set-render-size";
     content: SetRenderSizePayload;
 }
+/**
+ * Auto-track a moving vessel with a pan+zoom camera (or stop). The sidecar
+ * holds the chosen `mode` per camera and publishes it in
+ * `CameraState.track_mode`, so tracking state is server-authoritative and
+ * consistent across browsers. A browser track OVERRIDES a kOS aim on the
+ * same camera; send `mode: none` to hand aiming back to kOS.
+ */
+ | {
+    type: "set-track-target";
+    content: SetTrackTargetPayload;
+}
+/**
+ * A consumer reporting its OWN current display size in px; the sidecar
+ * aggregates MAX-across-consumers to drive auto-resolution
+ * (meet-the-minimum-need). Distinct from the operator `SetRenderSize`
+ * command: this is a per-consumer input, not a shared override — a
+ * departing consumer's size is cleared so the max relaxes.
+ */
+ | {
+    type: "report-display-size";
+    content: ReportDisplaySizePayload;
+}
+/**
+ * Force a camera to render at the operator ceiling regardless of
+ * display-size demand. Per-viewer, OR-aggregated by the sidecar: a
+ * feed stays forced while any connected viewer forces it, and
+ * releases when the last one clears it (or disconnects). Still
+ * yields to the adaptive framerate shed; overrides only the demand
+ * term, never the perf-protection ceiling.
+ */
+ | {
+    type: "set-force-full-resolution";
+    content: SetForceFullResolutionPayload;
+}
 /**
  * Set the camera's field-of-view (degrees). Silently ignored for
  * parts whose Hullcam module is the fixed base (`supportsZoom ==

package/dist/__generated__/types.js

@@ -13,6 +13,37 @@ export var CameraLifecycle;
     CameraLifecycle["Active"] = "active";
     CameraLifecycle["Destroyed"] = "destroyed";
 })(CameraLifecycle || (CameraLifecycle = {}));
+/**
+ * Distinguishes an existing Hullcam part camera (`Part`) from a
+ * per-kerbal face camera (`Kerbal`).
+ */
+export var CameraKind;
+(function (CameraKind) {
+    CameraKind["Part"] = "part";
+    CameraKind["Kerbal"] = "kerbal";
+})(CameraKind || (CameraKind = {}));
+/**
+ * Which source a kerbal camera is currently rendering: a seated IVA
+ * portrait, or the kerbal's own view while on EVA. Only meaningful when
+ * `CameraState.kind == Kerbal`.
+ */
+export var CrewLocation;
+(function (CrewLocation) {
+    CrewLocation["Seat"] = "seat";
+    CrewLocation["Eva"] = "eva";
+})(CrewLocation || (CrewLocation = {}));
+/**
+ * Which moving thing a pan+zoom camera should auto-aim at. `None` = tracking
+ * off (manual pan resumes). `ActiveVessel` and `Target` resolve to a world
+ * position from `FlightGlobals` (the active vessel, or its target) with no
+ * orbit math. Only surfaces on cameras with BOTH pan and zoom.
+ */
+export var TrackMode;
+(function (TrackMode) {
+    TrackMode["None"] = "none";
+    TrackMode["ActiveVessel"] = "activeVessel";
+    TrackMode["Target"] = "target";
+})(TrackMode || (TrackMode = {}));
 /**
  * Layer mask. Mirrors `Kerbcast.CameraLayers` on the plugin side.
  * Receiving clients use this for both the rendered-layer status reports

package/dist/client.d.ts

@@ -1,5 +1,6 @@
-import type { AdaptiveShedPayload, CameraState, ClientMessage, ErrorPayload, Layer, QualityPreset, SettingsStatePayload } from "./__generated__/types";
+import type { AdaptiveShedPayload, CameraState, ClientMessage, ErrorPayload, Layer, QualityPreset, SettingsStatePayload, TrackMode } from "./__generated__/types";
 import { CameraLifecycle } from "./__generated__/types";
+import { RecordingController, type RecordingControllerOptions } from "./recording";
 /** Controls the digital-static noise overlay baked into `cam.mediaStream`. */
 export interface NoiseConfig {
     /** When false, the pipeline is bypassed and `mediaStream` is the raw WebRTC track. */
@@ -22,6 +23,19 @@ export interface KerbcastCameraHandle {
     readonly stalled: boolean;
     /** Current {@link setShowStatic} setting. */
     readonly showStatic: boolean;
+    /**
+     * The feed's physical/ceiling maximum render size (`DiscoveredCamera.maxWidth`
+     * / `maxHeight`), or `null` until known. Populated from a prior
+     * `client.discover()` call (there is no live-pushed field for it), so a
+     * consumer that never calls `discover()` sees `null` here indefinitely.
+     * Used by `RecordingController` to recognise a force-full-resolution feed
+     * that has actually reached its ceiling, as opposed to one merely
+     * unchanged since before the force was sent.
+     */
+    readonly maxRenderSize: {
+        width: number;
+        height: number;
+    } | null;
     setLayers(layers: Layer[]): Promise<void>;
     setRenderSize(width: number, height: number): Promise<void>;
     setFov(fov: number): Promise<void>;
@@ -52,6 +66,15 @@ export interface KerbcastCameraHandle {
      * machinery keeps overriding it downward while throttled.
      */
     setQuality(preset: QualityPreset | null): Promise<void>;
+    /**
+     * Force this feed to render at the operator's configured maximum
+     * regardless of display size, until released by calling this with
+     * `false`. Per-viewer, OR-aggregated server-side across viewers: a feed
+     * stays forced while any viewer forces it, and releases when the last one
+     * clears it (or disconnects). Still yields to the adaptive framerate
+     * shed; it only overrides the display-size demand term.
+     */
+    setForceFullResolution(force: boolean): Promise<void>;
     requestKeyframe(): Promise<void>;
     /**
      * Override noise settings for this camera only. Takes precedence over the
@@ -121,6 +144,15 @@ export interface KerbcastClientConfig {
         sdp: string;
         cameras: number[];
     }>;
+    /**
+     * Options for the lazily-built {@link RecordingController} (`client.recording`).
+     * The load-bearing use is `loadTrimmer`: a consumer that can't rely on the
+     * default bare `import("mediabunny")` resolving (the sidecar's embedded web
+     * page serves its own copy of the package locally, offline/LAN, no CDN)
+     * supplies its own loader here. Bundler consumers (e.g. gonogo) can omit
+     * this and get the default.
+     */
+    recording?: RecordingControllerOptions;
 }
 /** WebRTC connection state surface. */
 export type KerbcastConnectionState = "disconnected" | "connecting" | "connected" | "failed";
@@ -328,6 +360,15 @@ export declare class KerbcastClient extends TypedEmitter<KerbcastClientEvents> {
     private _warpRate;
     /** Whether KSP is in a flight scene. `undefined` until the first signal. */
     private _inFlight;
+    /** Client-side recording controller, lazily built on first `recording` access. */
+    private _recording;
+    /**
+     * Physical/ceiling max render size per camera, cached from the last
+     * `discover()` call. Empty until `discover()` has been called at least
+     * once; a camera absent from the last discovery response is simply
+     * missing here (its handle's `maxRenderSize` reads `null`).
+     */
+    private readonly maxRenderSizeByFlight;
     constructor(cfg: KerbcastClientConfig, transport?: KerbcastTransport);
     get state(): KerbcastConnectionState;
     get cameras(): ReadonlyArray<CameraState>;
@@ -352,6 +393,13 @@ export declare class KerbcastClient extends TypedEmitter<KerbcastClientEvents> {
         epoch: number;
         warpRate: number;
     };
+    /**
+     * Client-side recording controller. Records a camera's already-received
+     * track with the browser's `MediaRecorder`, annotated with the mission-time
+     * (UT) clock; purely local, no sidecar involvement. Lazily created on first
+     * access and stable thereafter. See {@link RecordingController}.
+     */
+    get recording(): RecordingController;
     /**
      * Whether KSP is currently in a flight scene, from the sidecar's
      * `scene-state-changed`. `undefined` until the first signal (so a
@@ -371,6 +419,14 @@ export declare class KerbcastClient extends TypedEmitter<KerbcastClientEvents> {
      * to subscribe to before opening a peer connection.
      */
     discover(): Promise<DiscoveredCamera[]>;
+    /**
+     * Internal: backs {@link KerbcastCameraHandle.maxRenderSize}. `null` when
+     * `discover()` has never been called or never reported this camera.
+     */
+    _maxRenderSize(flightId: number): {
+        width: number;
+        height: number;
+    } | null;
     /**
      * Open the WebRTC peer and subscribe to cameras. Idempotent: calling
      * `connect` while already connected disconnects first.
@@ -409,6 +465,23 @@ export declare class KerbcastClient extends TypedEmitter<KerbcastClientEvents> {
      * goes null once the sidecar confirms with a SlotMap.
      */
     unsubscribe(flightId: number): Promise<void>;
+    /**
+     * Report this consumer's own displayed pixel size for a camera, driving the
+     * sidecar's auto-resolution. Unlike `setRenderSize` (an operator command that
+     * sets the shared render size directly, last-writer-wins), this is a
+     * per-consumer input the sidecar aggregates MAX-across-consumers, so a big
+     * spotlight bumps the stream up while tiny avatars leave it small. The SDK's
+     * feed primitives self-measure and call this; consumers do not report by hand.
+     */
+    reportDisplaySize(flightId: number, width: number, height: number): Promise<void>;
+    /**
+     * Ask a pan+zoom camera to auto-track a moving vessel (or stop). Sends the
+     * intent; the sidecar holds the chosen mode per camera and publishes it in
+     * `CameraState.trackMode`, so the UI must reflect that server-confirmed value
+     * rather than this call (two browsers stay in agreement). While tracking, the
+     * camera also auto-zooms; `TrackMode.None` hands aiming/zoom back.
+     */
+    setTrackTarget(flightId: number, mode: TrackMode): Promise<void>;
     /**
      * Internal — resolves the effective noise enabled state for a camera,
      * merging the per-camera override (if any) with the client-level default.

package/dist/client.js

@@ -1,5 +1,6 @@
 import { CameraLifecycle, ErrorSource } from "./__generated__/types";
 import { tryCreateNoisePipeline } from "./noise";
+import { RecordingController } from "./recording";
 /** Intensity the static runs at when a camera has no live source (signal lost). */
 const SOURCELESS_INTENSITY = 1.0;
 /** Floor applied to the degrade-driven intensity of a live feed. */
@@ -185,6 +186,9 @@ class CameraHandle extends TypedEmitter {
     get showStatic() {
         return this._showStatic;
     }
+    get maxRenderSize() {
+        return this.client._maxRenderSize(this.flightId);
+    }
     configure(options) {
         this._noiseOverride = options.noise ?? null;
         // Re-evaluate with the new noise setting: rebuild from whatever source
@@ -390,6 +394,12 @@ class CameraHandle extends TypedEmitter {
             content: { flightId: this.flightId, preset: preset ?? undefined },
         });
     }
+    async setForceFullResolution(force) {
+        await this.client._send({
+            type: "set-force-full-resolution",
+            content: { flightId: this.flightId, force },
+        });
+    }
     async requestKeyframe() {
         await this.client._send({
             type: "request-keyframe",
@@ -465,6 +475,15 @@ export class KerbcastClient extends TypedEmitter {
         this._warpRate = 1;
         /** Whether KSP is in a flight scene. `undefined` until the first signal. */
         this._inFlight = undefined;
+        /** Client-side recording controller, lazily built on first `recording` access. */
+        this._recording = null;
+        /**
+         * Physical/ceiling max render size per camera, cached from the last
+         * `discover()` call. Empty until `discover()` has been called at least
+         * once; a camera absent from the last discovery response is simply
+         * missing here (its handle's `maxRenderSize` reads `null`).
+         */
+        this.maxRenderSizeByFlight = new Map();
         this.cfg = cfg;
         this.transport =
             transport ??
@@ -507,6 +526,17 @@ export class KerbcastClient extends TypedEmitter {
             warpRate: this._warpRate,
         };
     }
+    /**
+     * Client-side recording controller. Records a camera's already-received
+     * track with the browser's `MediaRecorder`, annotated with the mission-time
+     * (UT) clock; purely local, no sidecar involvement. Lazily created on first
+     * access and stable thereafter. See {@link RecordingController}.
+     */
+    get recording() {
+        if (!this._recording)
+            this._recording = new RecordingController(this, this.cfg.recording);
+        return this._recording;
+    }
     /**
      * Whether KSP is currently in a flight scene, from the sidecar's
      * `scene-state-changed`. `undefined` until the first signal (so a
@@ -537,8 +567,21 @@ export class KerbcastClient extends TypedEmitter {
         if (!res.ok)
             throw new Error(`/cameras returned ${res.status}`);
         const body = (await res.json());
+        for (const cam of body.cameras) {
+            this.maxRenderSizeByFlight.set(cam.flightId, {
+                width: cam.maxWidth,
+                height: cam.maxHeight,
+            });
+        }
         return body.cameras;
     }
+    /**
+     * Internal: backs {@link KerbcastCameraHandle.maxRenderSize}. `null` when
+     * `discover()` has never been called or never reported this camera.
+     */
+    _maxRenderSize(flightId) {
+        return this.maxRenderSizeByFlight.get(flightId) ?? null;
+    }
     /**
      * Open the WebRTC peer and subscribe to cameras. Idempotent: calling
      * `connect` while already connected disconnects first.
@@ -658,6 +701,27 @@ export class KerbcastClient extends TypedEmitter {
     async unsubscribe(flightId) {
         await this._send({ type: "unsubscribe", content: { flightId } });
     }
+    /**
+     * Report this consumer's own displayed pixel size for a camera, driving the
+     * sidecar's auto-resolution. Unlike `setRenderSize` (an operator command that
+     * sets the shared render size directly, last-writer-wins), this is a
+     * per-consumer input the sidecar aggregates MAX-across-consumers, so a big
+     * spotlight bumps the stream up while tiny avatars leave it small. The SDK's
+     * feed primitives self-measure and call this; consumers do not report by hand.
+     */
+    async reportDisplaySize(flightId, width, height) {
+        await this._send({ type: "report-display-size", content: { flightId, width, height } });
+    }
+    /**
+     * Ask a pan+zoom camera to auto-track a moving vessel (or stop). Sends the
+     * intent; the sidecar holds the chosen mode per camera and publishes it in
+     * `CameraState.trackMode`, so the UI must reflect that server-confirmed value
+     * rather than this call (two browsers stay in agreement). While tracking, the
+     * camera also auto-zooms; `TrackMode.None` hands aiming/zoom back.
+     */
+    async setTrackTarget(flightId, mode) {
+        await this._send({ type: "set-track-target", content: { flightId, mode } });
+    }
     /**
      * Internal — resolves the effective noise enabled state for a camera,
      * merging the per-camera override (if any) with the client-level default.

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./__generated__/types";
 export { KerbcastClient, BrowserKerbcastTransport, type BrowserKerbcastTransportOptions, type InboundVideoStats, type KerbcastCameraHandle, type KerbcastClientConfig, type KerbcastConnectionState, type KerbcastClientEvents, type KerbcastCameraEvents, type KerbcastTransport, type KerbcastPeer, type KerbcastDataChannel, type DiscoveredCamera, type NoiseConfig, } from "./client";
 export { PanZoomController, type PanZoomCommandSink, type PanZoomBounds, type PanZoomControllerOptions, } from "./panZoom";
+export { RecordingController, createMediabunnyTrimmerLoader, negotiateMimeType, commonUtWindow, utToRecordingTimeMs, DEFAULT_COVERAGE_TIMEOUT_MS, ARM_TIMEOUT_MS, type ActiveRecordingInfo, type RecordingClient, type RecordingControllerOptions, type RecordingHandle, type RecordingsSnapshot, type GroupedRecordingHandle, type GroupedRecordingStart, type GroupTrimmer, type TrimmerLoader, type UtSample, type StartRecordingOptions, type StopGroupedRecordingOptions, } from "./recording";

package/dist/index.js

@@ -5,3 +5,4 @@
 export * from "./__generated__/types";
 export { KerbcastClient, BrowserKerbcastTransport, } from "./client";
 export { PanZoomController, } from "./panZoom";
+export { RecordingController, createMediabunnyTrimmerLoader, negotiateMimeType, commonUtWindow, utToRecordingTimeMs, DEFAULT_COVERAGE_TIMEOUT_MS, ARM_TIMEOUT_MS, } from "./recording";