@stim-cli/server 1.10.0 → 1.11.0

package/dist/{protocol-dn2_TUeH.mjs → protocol-CmlG7X7_.mjs}

@@ -1,7 +1,8 @@
 //#region src/protocol.ts
 const PROTOCOL_VERSION = 1;
 const PROTOCOL_SCHEMA_FILE = "protocol.schema.json";
-const CAPABILITIES = ["read"];
+/** `read` serves state. `control` also runs {@link ACTIONS}; only the Mac grants it. */
+const CAPABILITIES = ["read", "control"];
 const METHODS = [
 	"hello",
 	"status.subscribe",
@@ -10,7 +11,12 @@ const METHODS = [
 	"stats.get",
 	"settings.get",
 	"frames.subscribe",
-	"unsubscribe"
+	"frames.keyframe",
+	"build.plan",
+	"machine.get",
+	"machine.history",
+	"unsubscribe",
+	"action"
 ];
 /**
 * `unauthorized`, `pairing-expired` and `protocol-unsupported` refuse the client until it pairs again or
@@ -31,13 +37,18 @@ const ERROR_CODES = [
 	"status-failed",
 	"logs-failed",
 	"stim-failed",
-	"frames-failed"
+	"frames-failed",
+	"forbidden",
+	"unknown-action",
+	"action-busy",
+	"action-failed"
 ];
 const LOG_SOURCES = [
 	"metro",
 	"client",
 	"device",
-	"build"
+	"build",
+	"agent"
 ];
 const LOG_LEVELS = [
 	"debug",
@@ -47,6 +58,22 @@ const LOG_LEVELS = [
 	"fatal"
 ];
 const MAX_LOG_TAIL = 5e3;
+const FRAME_FPS = {
+	default: 5,
+	max: 30,
+	video: 60
+};
+const FRAME_EDGE = {
+	min: 240,
+	default: 1280,
+	max: 2048
+};
+const VIDEO_CODECS = ["h264"];
+const VIDEO_HEADER_VERSION = 1;
+/** The keyframe bit of a {@link VideoPacket}'s flags. */
+const VIDEO_KEYFRAME = 1;
+/** Each action runs one fixed `stim` command in the workspace. */
+const ACTIONS = ["reload", "stop"];
 const requestId = { type: ["integer", "string"] };
 const protocolError = {
 	type: "object",
@@ -140,6 +167,7 @@ function protocolJsonSchema() {
 					"protocol",
 					"server",
 					"capabilities",
+					"actions",
 					"device"
 				],
 				additionalProperties: false,
@@ -150,19 +178,25 @@ function protocolJsonSchema() {
 						required: [
 							"name",
 							"version",
-							"stim"
+							"stim",
+							"home"
 						],
 						additionalProperties: false,
 						properties: {
 							name: { type: "string" },
 							version: { type: "string" },
-							stim: { type: "string" }
+							stim: { type: "string" },
+							home: { type: "string" }
 						}
 					},
 					capabilities: {
 						type: "array",
 						items: { enum: [...CAPABILITIES] }
 					},
+					actions: {
+						type: "array",
+						items: { enum: [...ACTIONS] }
+					},
 					device: {
 						type: "object",
 						required: ["id", "name"],
@@ -231,6 +265,81 @@ function protocolJsonSchema() {
 						type: "string",
 						minLength: 1,
 						default: "default"
+					},
+					fps: {
+						type: "integer",
+						minimum: 1,
+						maximum: FRAME_FPS.video,
+						default: FRAME_FPS.default,
+						description: `At most ${FRAME_FPS.max} unless the result offers video.`
+					},
+					maxEdge: {
+						type: "integer",
+						minimum: FRAME_EDGE.min,
+						maximum: FRAME_EDGE.max,
+						default: FRAME_EDGE.default
+					},
+					video: {
+						type: "array",
+						items: { enum: [...VIDEO_CODECS] }
+					}
+				}
+			},
+			ActionParams: { oneOf: [{
+				type: "object",
+				required: ["action", "workspace"],
+				additionalProperties: false,
+				properties: {
+					action: { const: "reload" },
+					workspace: {
+						type: "string",
+						description: "An environment path from a status payload."
+					},
+					platform: { enum: ["ios", "android"] }
+				}
+			}, {
+				type: "object",
+				required: ["action", "workspace"],
+				additionalProperties: false,
+				properties: {
+					action: { const: "stop" },
+					workspace: {
+						type: "string",
+						description: "An environment path from a status payload."
+					}
+				}
+			}] },
+			ActionResult: {
+				type: "object",
+				required: [
+					"action",
+					"workspace",
+					"output"
+				],
+				additionalProperties: false,
+				properties: {
+					action: { enum: [...ACTIONS] },
+					workspace: { type: "string" },
+					output: {
+						type: "object",
+						description: "The JSON the command printed."
+					}
+				}
+			},
+			BuildPlanParams: {
+				type: "object",
+				required: ["workspace", "platform"],
+				additionalProperties: false,
+				properties: {
+					workspace: {
+						type: "string",
+						description: "An environment path from a status payload."
+					},
+					platform: { enum: ["ios", "android"] },
+					slot: {
+						type: "string",
+						pattern: "^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$",
+						default: "default"
 					}
 				}
 			},
@@ -242,12 +351,142 @@ function protocolJsonSchema() {
 					description: "An environment path from a status payload."
 				} }
 			},
+			MachineHistory: {
+				type: "object",
+				required: ["intervalMs", "samples"],
+				additionalProperties: false,
+				properties: {
+					intervalMs: { type: "integer" },
+					samples: {
+						type: "array",
+						items: {
+							type: "object",
+							required: [
+								"at",
+								"cpu",
+								"memoryUsedBytes",
+								"memoryPressure",
+								"diskFreeBytes"
+							],
+							additionalProperties: false,
+							properties: {
+								at: { type: "integer" },
+								cpu: { type: ["number", "null"] },
+								memoryUsedBytes: { type: ["number", "null"] },
+								memoryPressure: { enum: [
+									0,
+									1,
+									2,
+									null
+								] },
+								diskFreeBytes: { type: ["number", "null"] }
+							}
+						}
+					}
+				}
+			},
+			MachineUsage: {
+				type: "object",
+				required: [
+					"volumes",
+					"memory",
+					"load",
+					"cpu",
+					"sampledAt"
+				],
+				additionalProperties: false,
+				properties: {
+					volumes: {
+						type: "array",
+						items: {
+							type: "object",
+							required: [
+								"mount",
+								"holds",
+								"freeBytes",
+								"totalBytes"
+							],
+							additionalProperties: false,
+							properties: {
+								mount: { type: "string" },
+								holds: {
+									type: "array",
+									items: { type: "string" }
+								},
+								freeBytes: { type: "number" },
+								totalBytes: { type: "number" }
+							}
+						}
+					},
+					memory: {
+						type: "object",
+						required: [
+							"totalBytes",
+							"usedBytes",
+							"pressure"
+						],
+						additionalProperties: false,
+						properties: {
+							totalBytes: { type: "number" },
+							usedBytes: { type: ["number", "null"] },
+							pressure: { enum: [
+								"normal",
+								"warning",
+								"critical",
+								null
+							] }
+						}
+					},
+					load: {
+						type: "object",
+						required: [
+							"avg1",
+							"avg5",
+							"avg15",
+							"cpus"
+						],
+						additionalProperties: false,
+						properties: {
+							avg1: { type: "number" },
+							avg5: { type: "number" },
+							avg15: { type: "number" },
+							cpus: { type: "integer" }
+						}
+					},
+					cpu: {
+						type: "object",
+						required: ["usage", "cores"],
+						additionalProperties: false,
+						properties: {
+							usage: { type: ["number", "null"] },
+							cores: { type: "integer" }
+						}
+					},
+					sampledAt: {
+						type: "string",
+						format: "date-time"
+					}
+				}
+			},
 			ClientRequest: { oneOf: [
 				request("hello", { $ref: "#/$defs/HelloParams" }),
 				request("status.subscribe"),
 				request("logs.query", { $ref: "#/$defs/LogFilter" }),
 				request("logs.subscribe", { $ref: "#/$defs/LogFilter" }),
 				request("frames.subscribe", { $ref: "#/$defs/FrameTarget" }),
+				request("frames.keyframe", {
+					type: "object",
+					required: ["subscription"],
+					additionalProperties: false,
+					properties: { subscription: { type: "string" } }
+				}),
+				request("build.plan", { $ref: "#/$defs/BuildPlanParams" }),
+				request("machine.get"),
+				optionalParams("machine.history", {
+					type: "object",
+					additionalProperties: false,
+					properties: { sinceMs: { type: "number" } }
+				}),
 				optionalParams("stats.get", { $ref: "#/$defs/WorkspaceParams" }),
 				optionalParams("settings.get", { $ref: "#/$defs/WorkspaceParams" }),
 				request("unsubscribe", {
@@ -255,7 +494,8 @@ function protocolJsonSchema() {
 					required: ["subscription"],
 					additionalProperties: false,
 					properties: { subscription: { type: "string" } }
-				})
+				}),
+				request("action", { $ref: "#/$defs/ActionParams" })
 			] },
 			ServerResponse: { oneOf: [{
 				type: "object",
@@ -265,11 +505,17 @@ function protocolJsonSchema() {
 					id: requestId,
 					result: { anyOf: [
 						{ $ref: "#/$defs/HelloResult" },
+						{ $ref: "#/$defs/ActionResult" },
+						{ $ref: "#/$defs/MachineUsage" },
+						{ $ref: "#/$defs/MachineHistory" },
 						{
 							type: "object",
 							required: ["subscription"],
 							additionalProperties: false,
-							properties: { subscription: { type: "string" } }
+							properties: {
+								subscription: { type: "string" },
+								video: { enum: [...VIDEO_CODECS] }
+							}
 						},
 						{
 							type: "object",
@@ -282,7 +528,7 @@ function protocolJsonSchema() {
 						},
 						{
 							type: "object",
-							description: "The payload of `stim stats --json` or `stim settings --json`, or {} for unsubscribe."
+							description: "The payload of `stim stats --json`, `stim settings --json` or `stim ios|android --plan --json`, or {} for unsubscribe."
 						}
 					] }
 				}
@@ -363,7 +609,22 @@ function protocolJsonSchema() {
 						data: {
 							type: "string",
 							contentEncoding: "base64"
-						}
+						},
+						posture: { enum: ["folded", "unfolded"] }
+					}
+				},
+				{
+					type: "object",
+					required: [
+						"event",
+						"subscription",
+						"delayed"
+					],
+					additionalProperties: false,
+					properties: {
+						event: { const: "frame-delayed" },
+						subscription: { type: "string" },
+						delayed: { type: "boolean" }
 					}
 				},
 				{
@@ -390,4 +651,4 @@ function protocolJsonSchema() {
 	};
 }
 //#endregion
-export { MAX_LOG_TAIL as a, PROTOCOL_VERSION as c, LOG_SOURCES as i, protocolJsonSchema as l, ERROR_CODES as n, METHODS as o, LOG_LEVELS as r, PROTOCOL_SCHEMA_FILE as s, CAPABILITIES as t };
+export { FRAME_FPS as a, MAX_LOG_TAIL as c, PROTOCOL_VERSION as d, VIDEO_CODECS as f, protocolJsonSchema as h, FRAME_EDGE as i, METHODS as l, VIDEO_KEYFRAME as m, CAPABILITIES as n, LOG_LEVELS as o, VIDEO_HEADER_VERSION as p, ERROR_CODES as r, LOG_SOURCES as s, ACTIONS as t, PROTOCOL_SCHEMA_FILE as u };

package/dist/protocol.d.mts

@@ -1,16 +1,17 @@
-import { NdjsonRecord, StatusPayload } from "@stim-cli/core/state";
+import { BuildPlanPayload, NdjsonRecord, StatusPayload } from "@stim-cli/core/state";
 //#region src/protocol.d.ts
 declare const PROTOCOL_VERSION = 1;
 declare const PROTOCOL_SCHEMA_FILE = "protocol.schema.json";
-declare const CAPABILITIES: readonly ["read"];
+/** `read` serves state. `control` also runs {@link ACTIONS}; only the Mac grants it. */
+declare const CAPABILITIES: readonly ["read", "control"];
 type Capability = (typeof CAPABILITIES)[number];
-declare const METHODS: readonly ["hello", "status.subscribe", "logs.query", "logs.subscribe", "stats.get", "settings.get", "frames.subscribe", "unsubscribe"];
+declare const METHODS: readonly ["hello", "status.subscribe", "logs.query", "logs.subscribe", "stats.get", "settings.get", "frames.subscribe", "frames.keyframe", "build.plan", "machine.get", "machine.history", "unsubscribe", "action"];
 type Method = (typeof METHODS)[number];
 /**
  * `unauthorized`, `pairing-expired` and `protocol-unsupported` refuse the client until it pairs again or
  * updates; clients retry the others.
  */
-declare const ERROR_CODES: readonly ["unauthorized", "pairing-expired", "protocol-unsupported", "identity-unavailable", "bad-request", "unknown-method", "already-authenticated", "unknown-subscription", "unknown-workspace", "limit-exceeded", "slow-client", "status-failed", "logs-failed", "stim-failed", "frames-failed"];
+declare const ERROR_CODES: readonly ["unauthorized", "pairing-expired", "protocol-unsupported", "identity-unavailable", "bad-request", "unknown-method", "already-authenticated", "unknown-subscription", "unknown-workspace", "limit-exceeded", "slow-client", "status-failed", "logs-failed", "stim-failed", "frames-failed", "forbidden", "unknown-action", "action-busy", "action-failed"];
 type ErrorCode = (typeof ERROR_CODES)[number];
 type RequestId = number | string;
 /** Spends a single-use pairing token; the result carries the new device token. */
@@ -32,13 +33,19 @@ interface HelloParams {
 }
 interface HelloResult {
   protocol: number;
-  /** The Mac's name, this package's version, and the version of the `stim` it runs. */
+  /**
+   * The Mac's name, this package's version, the version of the `stim` it runs, and the home directory of the
+   * user it runs as, so clients can show paths under it as `~/...`.
+   */
   server: {
     name: string;
     version: string;
     stim: string;
+    home: string;
   };
   capabilities: Capability[];
+  /** The actions this device may run: every one of {@link ACTIONS} with `control`, none without. */
+  actions: ActionName[];
   /** The paired device this connection authenticated as, as `stim-server devices` lists it. */
   device: {
     id: string;
@@ -53,7 +60,7 @@ interface SubscribeResult {
 interface UnsubscribeParams {
   subscription: string;
 }
-declare const LOG_SOURCES: readonly ["metro", "client", "device", "build"];
+declare const LOG_SOURCES: readonly ["metro", "client", "device", "build", "agent"];
 type LogSource = (typeof LOG_SOURCES)[number];
 declare const LOG_LEVELS: readonly ["debug", "info", "warn", "error", "fatal"];
 type LogLevel = (typeof LOG_LEVELS)[number];
@@ -86,14 +93,151 @@ type StatsResult = Record<string, unknown>;
 /** `stim settings --json`; the CLI masks sensitive values. */
 type SettingsResult = Record<string, unknown>;
 type Platform = "ios" | "android";
+declare const FRAME_FPS: {
+  readonly default: 5;
+  readonly max: 30;
+  readonly video: 60;
+};
+declare const FRAME_EDGE: {
+  readonly min: 240;
+  readonly default: 1280;
+  readonly max: 2048;
+};
 /**
  * A device `stim status` lists as owned by `workspace`, in `slot` (`default` when absent). Frames come only
- * from a booted simulator or a running emulator Stim created.
+ * from a booted simulator or a running emulator Stim created. `fps` caps how many frames a second this
+ * subscription gets, and `maxEdge` asks for frames scaled to fit that many pixels; the server may send smaller
+ * frames, and larger ones while another subscriber of the same device asks for more.
  */
 interface FrameTarget {
   workspace: string;
   platform: Platform;
   slot?: string;
+  fps?: number;
+  maxEdge?: number;
+  /** The codecs this client decodes. The server picks one when it can encode video; see {@link FramesSubscribeResult}. */
+  video?: VideoCodec[];
+}
+declare const VIDEO_CODECS: readonly ["h264"];
+type VideoCodec = (typeof VIDEO_CODECS)[number];
+/**
+ * With `video`, frames arrive as binary WebSocket messages, one H.264 access unit each; see {@link VideoPacket}.
+ * A subscription whose device cannot be encoded, such as an iPhone Duo, still sends JSON `frame` events.
+ */
+interface FramesSubscribeResult extends SubscribeResult {
+  video?: VideoCodec;
+}
+/** Asks for a keyframe on a video subscription, after the client lost its decoder state. */
+interface KeyframeParams {
+  subscription: string;
+}
+declare const VIDEO_HEADER_VERSION = 1;
+/** The keyframe bit of a {@link VideoPacket}'s flags. */
+declare const VIDEO_KEYFRAME = 1;
+/**
+ * The layout of a binary video message, big-endian: u8 version ({@link VIDEO_HEADER_VERSION}), u8 flags
+ * ({@link VIDEO_KEYFRAME}), u16 header length, u32 sequence number of the messages sent on this subscription, f64 capture time in milliseconds since the
+ * epoch on the Mac's clock, u16 width, u16 height, u8 subscription id length N, N bytes of ASCII subscription
+ * id. After the header comes one Annex-B H.264 access unit; a keyframe carries its SPS and PPS. The stream has
+ * no B-frames, so each access unit is shown as it arrives.
+ */
+interface VideoPacket {
+  subscription: string;
+  keyframe: boolean;
+  sequence: number;
+  capturedAt: number;
+  width: number;
+  height: number;
+  accessUnit: Uint8Array;
+}
+/** Each action runs one fixed `stim` command in the workspace. */
+declare const ACTIONS: readonly ["reload", "stop"];
+type ActionName = (typeof ACTIONS)[number];
+/**
+ * `reload` runs `stim reload --json`, with `platform` when both platforms are live; `stop` runs
+ * `stim stop --json`. `workspace` is an environment `path` from a status payload. Needs `control`.
+ */
+type ActionParams = {
+  action: "reload";
+  workspace: string;
+  platform?: Platform;
+} | {
+  action: "stop";
+  workspace: string;
+};
+/** `output` is the JSON the command printed. */
+interface ActionResult {
+  action: ActionName;
+  workspace: string;
+  output: Record<string, unknown>;
+}
+/** Predicts the next `ios` or `android` build of `workspace` in `slot` (`default` when absent). */
+interface BuildPlanParams {
+  workspace: string;
+  platform: Platform;
+  slot?: string;
+}
+/** `stim ios|android --plan --json`. It builds, boots and installs nothing, and writes no Stim state. */
+type BuildPlanResult = BuildPlanPayload;
+type MemoryPressure = "normal" | "warning" | "critical";
+/** A volume that holds Stim workspaces, Stim home, or the simulators. */
+interface MachineVolume {
+  /** `/`, or `/Volumes/<name>` for an external volume. */
+  mount: string;
+  /** What Stim keeps there: `Workspaces`, `Stim home`, `Simulators`. */
+  holds: string[];
+  /** Free space without purgeable space, which is what Stim's disk budget measures. */
+  freeBytes: number;
+  totalBytes: number;
+}
+/** Cheap machine usage, read in the server process without running `stim`. */
+interface MachineUsage {
+  volumes: MachineVolume[];
+  /**
+   * `usedBytes` is the Mac's memory in use, as Activity Monitor's "Memory Used" counts it: app memory, wired and
+   * compressed. `pressure` is the macOS memory pressure level. Both are null on other systems or when they cannot
+   * be read.
+   */
+  memory: {
+    totalBytes: number;
+    usedBytes: number | null;
+    pressure: MemoryPressure | null;
+  };
+  load: {
+    avg1: number;
+    avg5: number;
+    avg15: number;
+    cpus: number;
+  };
+  /**
+   * `usage` is the Mac's overall CPU busy fraction (0..1), from the tick delta between this call and the
+   * previous one. Null on the first call of a server process, since there is no previous sample yet.
+   */
+  cpu: {
+    usage: number | null;
+    cores: number;
+  };
+  sampledAt: string;
+}
+/**
+ * One `machine.history` sample. `at` is epoch milliseconds. `cpu` is the busy fraction (0..1) since the previous
+ * sample. `memoryPressure` is 0 (normal), 1 (warning) or 2 (critical). `diskFreeBytes` is the free space of the
+ * startup volume, `/`. A field is null when it could not be read.
+ */
+interface UsageSample {
+  at: number;
+  cpu: number | null;
+  memoryUsedBytes: number | null;
+  memoryPressure: 0 | 1 | 2 | null;
+  diskFreeBytes: number | null;
+}
+/** Returns only the samples taken after `sinceMs`, epoch milliseconds. */
+interface MachineHistoryParams {
+  sinceMs?: number;
+}
+interface MachineHistory {
+  intervalMs: number;
+  samples: UsageSample[];
 }
 interface Methods {
   hello: {
@@ -122,12 +266,32 @@ interface Methods {
   };
   "frames.subscribe": {
     params: FrameTarget;
-    result: SubscribeResult;
+    result: FramesSubscribeResult;
+  };
+  "frames.keyframe": {
+    params: KeyframeParams;
+    result: Record<string, never>;
+  };
+  "build.plan": {
+    params: BuildPlanParams;
+    result: BuildPlanResult;
+  };
+  "machine.get": {
+    params?: Record<string, never>;
+    result: MachineUsage;
+  };
+  "machine.history": {
+    params?: MachineHistoryParams;
+    result: MachineHistory;
   };
   unsubscribe: {
     params: UnsubscribeParams;
     result: Record<string, never>;
   };
+  action: {
+    params: ActionParams;
+    result: ActionResult;
+  };
 }
 type ClientRequest = { [M in Method]: {
   id: RequestId;
@@ -165,7 +329,7 @@ interface ErrorEvent {
   subscription: string;
   error: ProtocolError;
 }
-/** A screenshot of the device, sent when the screen changed, at most 5 times a second. */
+/** A frame of the device's screen, sent when the screen changed, at most `fps` times a second. */
 interface FrameEvent {
   event: "frame";
   subscription: string;
@@ -177,11 +341,26 @@ interface FrameEvent {
   capturedAt: string;
   /** Base64-encoded image bytes. */
   data: string;
+  /**
+   * An iPhone Duo's or Android foldable emulator's posture. A Duo reports the panel it lit: the cover when
+   * folded, the inner panel when unfolded. An emulator with a hinge reports `folded` while it shows only its
+   * outer display, and `unfolded` otherwise, including half open.
+   */
+  posture?: "folded" | "unfolded";
+}
+/**
+ * Captures for a `frames.subscribe` subscription are slow or a timed-out capture is being retried; the
+ * client keeps showing its last frame. Followed by `delayed: false` once captures recover.
+ */
+interface FrameDelayedEvent {
+  event: "frame-delayed";
+  subscription: string;
+  delayed: boolean;
 }
-type ServerEvent = StatusEvent | LogsEvent | FrameEvent | ErrorEvent;
+type ServerEvent = StatusEvent | LogsEvent | FrameEvent | FrameDelayedEvent | ErrorEvent;
 type ServerMessage = ServerResponse | ServerEvent;
 type JsonSchema = Record<string, unknown>;
 /** The JSON Schema of every message on the wire, written to `dist/protocol.schema.json` at build time. */
 declare function protocolJsonSchema(): JsonSchema;
 //#endregion
-export { CAPABILITIES, Capability, ClientRequest, DeviceAuth, ERROR_CODES, ErrorCode, ErrorEvent, FrameEvent, FrameTarget, HelloParams, HelloResult, LOG_LEVELS, LOG_SOURCES, LogFilter, LogLevel, LogRecord, LogSource, LogsEvent, LogsQueryResult, MAX_LOG_TAIL, METHODS, Method, Methods, PROTOCOL_SCHEMA_FILE, PROTOCOL_VERSION, PairingAuth, Platform, ProtocolError, RequestId, ServerEvent, ServerMessage, ServerResponse, SettingsResult, StatsResult, StatusEvent, SubscribeResult, UnsubscribeParams, WorkspaceParams, protocolJsonSchema };
+export { ACTIONS, ActionName, ActionParams, ActionResult, BuildPlanParams, BuildPlanResult, CAPABILITIES, Capability, ClientRequest, DeviceAuth, ERROR_CODES, ErrorCode, ErrorEvent, FRAME_EDGE, FRAME_FPS, FrameDelayedEvent, FrameEvent, FrameTarget, FramesSubscribeResult, HelloParams, HelloResult, KeyframeParams, LOG_LEVELS, LOG_SOURCES, LogFilter, LogLevel, LogRecord, LogSource, LogsEvent, LogsQueryResult, MAX_LOG_TAIL, METHODS, MachineHistory, MachineHistoryParams, MachineUsage, MachineVolume, MemoryPressure, Method, Methods, PROTOCOL_SCHEMA_FILE, PROTOCOL_VERSION, PairingAuth, Platform, ProtocolError, RequestId, ServerEvent, ServerMessage, ServerResponse, SettingsResult, StatsResult, StatusEvent, SubscribeResult, UnsubscribeParams, UsageSample, VIDEO_CODECS, VIDEO_HEADER_VERSION, VIDEO_KEYFRAME, VideoCodec, VideoPacket, WorkspaceParams, protocolJsonSchema };

package/dist/protocol.mjs

@@ -1,2 +1,2 @@
-import { a as MAX_LOG_TAIL, c as PROTOCOL_VERSION, i as LOG_SOURCES, l as protocolJsonSchema, n as ERROR_CODES, o as METHODS, r as LOG_LEVELS, s as PROTOCOL_SCHEMA_FILE, t as CAPABILITIES } from "./protocol-dn2_TUeH.mjs";
-export { CAPABILITIES, ERROR_CODES, LOG_LEVELS, LOG_SOURCES, MAX_LOG_TAIL, METHODS, PROTOCOL_SCHEMA_FILE, PROTOCOL_VERSION, protocolJsonSchema };
+import { a as FRAME_FPS, c as MAX_LOG_TAIL, d as PROTOCOL_VERSION, f as VIDEO_CODECS, h as protocolJsonSchema, i as FRAME_EDGE, l as METHODS, m as VIDEO_KEYFRAME, n as CAPABILITIES, o as LOG_LEVELS, p as VIDEO_HEADER_VERSION, r as ERROR_CODES, s as LOG_SOURCES, t as ACTIONS, u as PROTOCOL_SCHEMA_FILE } from "./protocol-CmlG7X7_.mjs";
+export { ACTIONS, CAPABILITIES, ERROR_CODES, FRAME_EDGE, FRAME_FPS, LOG_LEVELS, LOG_SOURCES, MAX_LOG_TAIL, METHODS, PROTOCOL_SCHEMA_FILE, PROTOCOL_VERSION, VIDEO_CODECS, VIDEO_HEADER_VERSION, VIDEO_KEYFRAME, protocolJsonSchema };