@ai-matrx/desktop-protocol 0.1.0

package/dist/client.cjs

@@ -0,0 +1,1309 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/client.ts
+var client_exports = {};
+__export(client_exports, {
+  DesktopProtocolError: () => DesktopProtocolError,
+  RECONNECT_ALARM_ATTEMPTS: () => import_realtime.RECONNECT_ALARM_ATTEMPTS,
+  createDesktopClient: () => createDesktopClient,
+  isDesktopProtocolError: () => isDesktopProtocolError
+});
+module.exports = __toCommonJS(client_exports);
+
+// src/client/client.ts
+var import_realtime = require("@ai-matrx/realtime");
+
+// src/error.ts
+var DesktopProtocolError = class extends Error {
+  code;
+  retryable;
+  data;
+  constructor(code, message, options = {}) {
+    super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
+    this.name = "DesktopProtocolError";
+    this.code = code;
+    this.retryable = options.retryable ?? false;
+    this.data = options.data;
+  }
+  /** The wire body (ProtocolErrorBody) — what a core or relay sends for this error. */
+  toBody() {
+    return this.data === void 0 ? { code: this.code, message: this.message, retryable: this.retryable } : { code: this.code, message: this.message, retryable: this.retryable, data: this.data };
+  }
+};
+function isDesktopProtocolError(value) {
+  return value instanceof DesktopProtocolError || value instanceof Error && value.name === "DesktopProtocolError" && "code" in value;
+}
+
+// src/frame.ts
+var FRAME_HEADER_BYTES = 16;
+var FRAME_VERSION = 1;
+var FrameChannel = {
+  /** core→client: pty output, fs.read_stream bytes */
+  DATA: 0,
+  /** core→client: stderr of a non-pty process (reserved for exec.spawn in v1.1) */
+  STDERR: 1,
+  /** client→core: keystrokes / stdin to sid */
+  STDIN: 2,
+  /** core→client: serialized terminal screen (attach when since_seq is outside the ring) */
+  SNAPSHOT: 3,
+  /** relay↔device hop only: a JSON envelope carried inside a binary frame so the relay can route
+   *  by cid without parsing JSON. Never seen by clients. */
+  ENVELOPE: 255
+};
+var U32_MAX = 4294967295;
+var CHANNELS = new Set(Object.values(FrameChannel));
+function frameError(message) {
+  return new DesktopProtocolError("PROTOCOL_ERROR", message);
+}
+function checkU32(name, value) {
+  if (!Number.isInteger(value) || value < 0 || value > U32_MAX) throw frameError(`frame ${name} is not a u32: ${value}`);
+}
+function assertFrameHeader(h) {
+  if (h.version !== FRAME_VERSION) throw frameError(`unsupported frame version ${String(h.version)}`);
+  if (!Number.isInteger(h.flags) || h.flags < 0 || h.flags > 3) throw frameError(`reserved frame flag bits set: ${h.flags}`);
+  if (!CHANNELS.has(h.channel)) throw frameError(`unknown frame channel ${String(h.channel)}`);
+  checkU32("cid", h.cid);
+  checkU32("sid", h.sid);
+  checkU32("seq", h.seq);
+}
+function encodeFrame(h, payload) {
+  assertFrameHeader(h);
+  const out = new Uint8Array(FRAME_HEADER_BYTES + payload.byteLength);
+  const v = new DataView(out.buffer);
+  v.setUint8(0, h.version);
+  v.setUint8(1, h.flags);
+  v.setUint8(2, h.channel);
+  v.setUint8(3, 0);
+  v.setUint32(4, h.cid);
+  v.setUint32(8, h.sid);
+  v.setUint32(12, h.seq);
+  out.set(payload, FRAME_HEADER_BYTES);
+  return out;
+}
+function decodeFrame(buf) {
+  const bytes = buf instanceof Uint8Array ? buf : new Uint8Array(buf);
+  if (bytes.byteLength < FRAME_HEADER_BYTES) throw frameError(`short frame: ${bytes.byteLength} bytes`);
+  const v = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  if (v.getUint8(3) !== 0) throw frameError("reserved frame byte 3 is not 0");
+  const header = {
+    version: v.getUint8(0),
+    flags: v.getUint8(1),
+    channel: v.getUint8(2),
+    cid: v.getUint32(4),
+    sid: v.getUint32(8),
+    seq: v.getUint32(12)
+  };
+  assertFrameHeader(header);
+  return { header, payload: bytes.subarray(FRAME_HEADER_BYTES) };
+}
+
+// src/schema/envelope.ts
+var import_zod3 = require("zod");
+
+// src/schema/errors.ts
+var import_zod2 = require("zod");
+
+// src/schema/primitives.ts
+var import_zod = require("zod");
+var PROTOCOL_MAJOR = 1;
+var PROTOCOL_MINOR = 0;
+var ProtocolVersion = import_zod.z.string().regex(/^[1-9][0-9]{0,2}\.[0-9]{1,3}$/);
+var RequestId = import_zod.z.string().min(1).max(64).regex(/^[A-Za-z0-9_-]+$/);
+var ResourceId = import_zod.z.string().regex(/^(pty|watch)_[A-Za-z0-9]{16,40}$/);
+var DeviceId = import_zod.z.string().regex(/^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/);
+var AbsPath = import_zod.z.string().min(1).max(4096).regex(/^(\/|[A-Za-z]:\/)[^\\\u0000]*$/);
+var u32 = import_zod.z.int().min(0).max(4294967295);
+var nonNegInt = import_zod.z.int().min(0);
+var epochMs = import_zod.z.int().min(0);
+
+// src/schema/errors.ts
+var ErrorCode = import_zod2.z.enum([
+  "AUTH_REQUIRED",
+  "AUTH_INVALID",
+  "AUTH_EXPIRED",
+  "AUTH_FORBIDDEN",
+  // signed in, but not this device's owner
+  "AUTH_DEVICE_REVOKED",
+  // kill switch
+  "PERMISSION_DENIED_OS",
+  "NOT_FOUND",
+  "CONFLICT",
+  "INVALID_PARAMS",
+  "RESOURCE_BUSY",
+  "RESOURCE_GONE",
+  "CANCELLED",
+  "TIMEOUT",
+  "PLATFORM_UNSUPPORTED",
+  "RATE_LIMITED",
+  "INTERNAL",
+  "PROTOCOL_VERSION_UNSUPPORTED",
+  // NEW: hello refused, carries data.upgrade
+  "PROTOCOL_ERROR",
+  // NEW: malformed envelope/frame, credit overrun, unknown sid
+  "UNKNOWN_OPERATION",
+  // NEW: cap.op not served by this core version
+  "DEVICE_OFFLINE",
+  // NEW: relay has no live device socket (retryable)
+  "PAYLOAD_TOO_LARGE"
+  // NEW: message or frame above limits.max_*_bytes
+]);
+var ErrorReason = import_zod2.z.enum([
+  "not_a_directory",
+  "is_a_directory",
+  "directory_not_empty",
+  "already_exists",
+  "stale_write",
+  // fs.write if_match_mtime_ms mismatch → CONFLICT
+  "binary_content",
+  // utf8 read of non-UTF-8 bytes → INVALID_PARAMS
+  "not_utf8_boundary",
+  "patch_no_match",
+  "patch_ambiguous",
+  "resource_exited",
+  "resource_expired",
+  "control_taken",
+  // another client of the same user took control
+  "window_exhausted"
+]);
+var ProtocolErrorBody = import_zod2.z.strictObject({
+  code: ErrorCode,
+  message: import_zod2.z.string().max(300),
+  // short, human, never a stack trace or a token
+  retryable: import_zod2.z.boolean(),
+  data: import_zod2.z.strictObject({
+    reason: ErrorReason.optional(),
+    cap: import_zod2.z.string().max(32).optional(),
+    op: import_zod2.z.string().max(64).optional(),
+    path: AbsPath.optional(),
+    settings_url: import_zod2.z.string().max(512).optional(),
+    // PERMISSION_DENIED_OS deep link
+    retry_after_ms: nonNegInt.optional(),
+    limit_bytes: nonNegInt.optional(),
+    upgrade: import_zod2.z.strictObject({
+      min_version: ProtocolVersion,
+      max_version: ProtocolVersion,
+      download_url: import_zod2.z.url().optional()
+    }).optional()
+  }).optional()
+});
+
+// src/schema/envelope.ts
+var ClientType = import_zod3.z.enum(["screen", "web", "extension", "server", "test"]);
+var Limits = import_zod3.z.strictObject({
+  max_message_bytes: import_zod3.z.int().min(65536),
+  max_frame_payload_bytes: import_zod3.z.int().min(4096),
+  default_window_bytes: import_zod3.z.int().min(4096),
+  max_streams_per_client: import_zod3.z.int().min(1),
+  max_resources_per_user: import_zod3.z.int().min(1)
+});
+var OpDescriptor = import_zod3.z.strictObject({ cap: import_zod3.z.string().max(32), op: import_zod3.z.string().max(64), since: ProtocolVersion });
+var Welcome = import_zod3.z.strictObject({
+  protocol_version: ProtocolVersion,
+  // negotiated = min(client, core) within the same major
+  session_id: import_zod3.z.string().min(8).max(64),
+  client_id: import_zod3.z.string().min(8).max(64),
+  // this connection's identity in the Session Manager
+  device_id: DeviceId,
+  device_name: import_zod3.z.string().max(128),
+  app_version: import_zod3.z.string().max(32),
+  platform: import_zod3.z.enum(["darwin", "win32", "linux"]),
+  ops: import_zod3.z.array(OpDescriptor),
+  limits: Limits,
+  server_time_ms: epochMs
+});
+var HelloMsg = import_zod3.z.strictObject({
+  type: import_zod3.z.literal("hello"),
+  id: RequestId,
+  // answered by response{id, result: Welcome} or error{id}
+  protocolVersion: ProtocolVersion,
+  clientType: ClientType,
+  clientVersion: import_zod3.z.string().min(1).max(32)
+});
+var RequestMsg = import_zod3.z.strictObject({
+  id: RequestId,
+  type: import_zod3.z.literal("request"),
+  cap: import_zod3.z.string().min(1).max(32),
+  op: import_zod3.z.string().min(1).max(64),
+  params: import_zod3.z.unknown()
+  // validated by the Router against OPS[cap.op].params — once, there
+});
+var ResponseMsg = import_zod3.z.strictObject({ id: RequestId, type: import_zod3.z.literal("response"), result: import_zod3.z.unknown() });
+var ErrorMsg = import_zod3.z.strictObject({ id: RequestId, type: import_zod3.z.literal("error"), error: ProtocolErrorBody });
+var StreamMeta = import_zod3.z.discriminatedUnion("kind", [
+  /** Binds request id → numeric sid; binary frames for this stream follow. */
+  import_zod3.z.strictObject({
+    kind: import_zod3.z.literal("open"),
+    sid: u32,
+    window_bytes: import_zod3.z.int().min(4096),
+    resource_id: ResourceId.optional()
+  }),
+  /** Frames after this (channel SNAPSHOT) are a serialized screen; live DATA resumes after. */
+  import_zod3.z.strictObject({ kind: import_zod3.z.literal("snapshot"), cols: import_zod3.z.int().min(1), rows: import_zod3.z.int().min(1) }),
+  /** Frames [from_seq, to_seq] are gone from the ring; a snapshot follows. */
+  import_zod3.z.strictObject({ kind: import_zod3.z.literal("gap"), from_seq: u32, to_seq: u32 })
+]);
+var StreamMsg = import_zod3.z.strictObject({ id: RequestId, type: import_zod3.z.literal("stream"), seq: u32, meta: StreamMeta });
+var EndReason = import_zod3.z.enum(["completed", "cancelled", "detached", "resource_exited", "error"]);
+var EndMsg = import_zod3.z.strictObject({ id: RequestId, type: import_zod3.z.literal("end"), seq: u32, reason: EndReason.optional() });
+var CancelMsg = import_zod3.z.strictObject({ id: RequestId, type: import_zod3.z.literal("cancel") });
+var CreditMsg = import_zod3.z.strictObject({ id: RequestId, type: import_zod3.z.literal("credit"), n: import_zod3.z.int().min(1).max(2147483647) });
+var EventMsg = import_zod3.z.strictObject({
+  type: import_zod3.z.literal("event"),
+  cap: import_zod3.z.string().min(1).max(32),
+  name: import_zod3.z.string().min(1).max(64),
+  payload: import_zod3.z.unknown(),
+  // validated against EVENTS[cap.name]
+  resourceId: ResourceId.optional()
+});
+var RelayMsg = import_zod3.z.discriminatedUnion("op", [
+  /** Fresh access token before the current one expires (relay closes 4008 at exp + 60 s). */
+  import_zod3.z.strictObject({ type: import_zod3.z.literal("relay"), op: import_zod3.z.literal("reauth"), token: import_zod3.z.string().min(16).max(8192) })
+]);
+var PING_TEXT = '{"type":"ping"}';
+var PONG_TEXT = '{"type":"pong"}';
+var ClientToCoreMsg = import_zod3.z.discriminatedUnion("type", [HelloMsg, RequestMsg, CancelMsg, CreditMsg]);
+var CoreToClientMsg = import_zod3.z.discriminatedUnion("type", [ResponseMsg, ErrorMsg, StreamMsg, EndMsg, CreditMsg, EventMsg]);
+var CloseCode = {
+  NORMAL: 1e3,
+  GOING_AWAY: 1001,
+  // relay deploy / app quit — reconnect immediately
+  AUTH_INVALID: 4001,
+  AUTH_FORBIDDEN: 4003,
+  DEVICE_NOT_FOUND: 4004,
+  AUTH_EXPIRED: 4008,
+  // no reauth before exp + 60 s
+  REPLACED: 4009,
+  // a newer device socket for the same device took over
+  DEVICE_REVOKED: 4010,
+  // kill switch — do NOT reconnect
+  PROTOCOL_ERROR: 4400,
+  UPGRADE_REQUIRED: 4426
+};
+
+// src/schema/frame.ts
+var import_zod4 = require("zod");
+var FrameHeader = import_zod4.z.strictObject({
+  version: import_zod4.z.literal(FRAME_VERSION),
+  flags: import_zod4.z.int().min(0).max(3),
+  channel: import_zod4.z.union([import_zod4.z.literal(0), import_zod4.z.literal(1), import_zod4.z.literal(2), import_zod4.z.literal(3), import_zod4.z.literal(255)]),
+  cid: u32,
+  sid: u32,
+  seq: u32
+});
+var DEFAULT_WINDOW_BYTES = 262144;
+var DEFAULT_MAX_FRAME_PAYLOAD_BYTES = 65536;
+
+// src/schema/sysinfo.ts
+var import_zod5 = require("zod");
+var OsPermissionName = import_zod5.z.enum([
+  "full_disk_access",
+  "accessibility",
+  "screen_recording",
+  "microphone",
+  "camera",
+  "automation",
+  "contacts",
+  "calendars",
+  "photos",
+  "location",
+  "local_network",
+  "bluetooth",
+  "notifications"
+]);
+var SysinfoGetParams = import_zod5.z.strictObject({});
+var SysinfoGetResult = import_zod5.z.strictObject({
+  device_id: DeviceId,
+  device_name: import_zod5.z.string().max(128),
+  hostname: import_zod5.z.string().max(255),
+  platform: import_zod5.z.enum(["darwin", "win32", "linux"]),
+  os_version: import_zod5.z.string().max(64),
+  arch: import_zod5.z.enum(["arm64", "x64"]),
+  app_version: import_zod5.z.string().max(32),
+  protocol_version: ProtocolVersion,
+  user: import_zod5.z.strictObject({ username: import_zod5.z.string().max(128), shell: import_zod5.z.string().max(512) }),
+  paths: import_zod5.z.strictObject({
+    home: AbsPath,
+    desktop: AbsPath,
+    documents: AbsPath,
+    downloads: AbsPath,
+    app_data: AbsPath,
+    temp: AbsPath
+  }),
+  cpu: import_zod5.z.strictObject({ model: import_zod5.z.string().max(128), cores: import_zod5.z.int().min(1) }),
+  memory: import_zod5.z.strictObject({ total_bytes: nonNegInt, free_bytes: nonNegInt }),
+  uptime_seconds: nonNegInt,
+  on_battery: import_zod5.z.boolean().nullable(),
+  sleep_prevented: import_zod5.z.boolean(),
+  // true while any remote session holds the power blocker
+  permissions: import_zod5.z.array(
+    import_zod5.z.strictObject({
+      name: OsPermissionName,
+      state: import_zod5.z.enum(["granted", "denied", "not_determined", "not_applicable"]),
+      settings_url: import_zod5.z.string().max(512).nullable()
+    })
+  )
+});
+
+// src/schema/fs.ts
+var import_zod6 = require("zod");
+var FsKind = import_zod6.z.enum(["file", "dir", "symlink"]);
+var FsEntry = import_zod6.z.strictObject({
+  name: import_zod6.z.string().max(1024),
+  path: AbsPath,
+  kind: FsKind,
+  size: nonNegInt,
+  mtime: import_zod6.z.number().min(0),
+  // seconds, float — daemon parity
+  mtime_ms: epochMs,
+  mode: import_zod6.z.int().min(0).max(4095),
+  target: AbsPath.nullable(),
+  // symlink target, never followed
+  hidden: import_zod6.z.boolean()
+});
+var FsListParams = import_zod6.z.strictObject({
+  path: AbsPath,
+  recursive: import_zod6.z.boolean().default(false),
+  depth: import_zod6.z.int().min(1).max(32).default(1),
+  pattern: import_zod6.z.string().max(256).optional(),
+  // glob on name
+  limit: import_zod6.z.int().min(1).max(5e3).default(500),
+  page_token: import_zod6.z.string().max(256).optional(),
+  show_hidden: import_zod6.z.boolean().default(false),
+  sort: import_zod6.z.enum(["name", "mtime", "size", "kind"]).default("kind")
+});
+var FsListResult = import_zod6.z.strictObject({
+  entries: import_zod6.z.array(FsEntry),
+  truncated: import_zod6.z.boolean(),
+  next_page_token: import_zod6.z.string().max(256).nullable(),
+  scanned: nonNegInt
+});
+var FsStatParams = import_zod6.z.strictObject({ path: AbsPath });
+var FsStatResult = FsEntry;
+var FsEncoding = import_zod6.z.enum(["utf8", "base64"]);
+var FsReadParams = import_zod6.z.strictObject({
+  path: AbsPath,
+  encoding: FsEncoding.default("utf8"),
+  offset: nonNegInt.default(0),
+  limit: import_zod6.z.int().min(1).max(4194304).default(262144)
+});
+var FsReadResult = import_zod6.z.strictObject({
+  content: import_zod6.z.string(),
+  encoding: FsEncoding,
+  size: nonNegInt,
+  offset: nonNegInt,
+  next_offset: nonNegInt,
+  truncated: import_zod6.z.boolean(),
+  mime: import_zod6.z.string().max(128).nullable(),
+  mtime_ms: epochMs
+  // pass back as if_match_mtime_ms to guard a later write
+});
+var FsReadStreamParams = import_zod6.z.strictObject({
+  path: AbsPath,
+  offset: nonNegInt.default(0),
+  length: nonNegInt.optional(),
+  // absent = to EOF
+  window_bytes: import_zod6.z.int().min(4096).max(16777216).optional()
+});
+var FsReadStreamResult = import_zod6.z.strictObject({ size: nonNegInt, mime: import_zod6.z.string().max(128).nullable(), mtime_ms: epochMs });
+var FsWriteParams = import_zod6.z.strictObject({
+  path: AbsPath,
+  content: import_zod6.z.string().max(5592406),
+  // ≤ 4 MiB of bytes after base64 decode
+  encoding: FsEncoding.default("utf8"),
+  mode: import_zod6.z.int().min(0).max(4095).optional(),
+  create_parents: import_zod6.z.boolean().default(false),
+  /** Optimistic concurrency: CONFLICT/stale_write if the file changed since this mtime. */
+  if_match_mtime_ms: epochMs.optional(),
+  /** Refuse to replace an existing file (CONFLICT/already_exists). */
+  exclusive: import_zod6.z.boolean().default(false)
+});
+var FsWriteResult = import_zod6.z.strictObject({ path: AbsPath, size: nonNegInt, mtime_ms: epochMs, created: import_zod6.z.boolean() });
+var FsMkdirParams = import_zod6.z.strictObject({ path: AbsPath, parents: import_zod6.z.boolean().default(false) });
+var FsMkdirResult = import_zod6.z.strictObject({ path: AbsPath, created: import_zod6.z.boolean() });
+var FsMoveParams = import_zod6.z.strictObject({ from_path: AbsPath, to_path: AbsPath, overwrite: import_zod6.z.boolean().default(false) });
+var FsMoveResult = import_zod6.z.strictObject({ from_path: AbsPath, to_path: AbsPath });
+var FsDeleteParams = import_zod6.z.strictObject({
+  path: AbsPath,
+  recursive: import_zod6.z.boolean().default(false),
+  to_trash: import_zod6.z.boolean().default(true)
+});
+var FsDeleteResult = import_zod6.z.strictObject({ deleted: import_zod6.z.literal(true), trashed_to: AbsPath.nullable() });
+var FsWatchParams = import_zod6.z.strictObject({
+  path: AbsPath,
+  recursive: import_zod6.z.boolean().default(false),
+  ignore: import_zod6.z.array(import_zod6.z.string().max(256)).max(64).default([]),
+  debounce_ms: import_zod6.z.int().min(0).max(5e3).default(50)
+});
+var FsWatchResult = import_zod6.z.strictObject({ resource_id: ResourceId, path: AbsPath });
+var FsPatchParams = import_zod6.z.strictObject({
+  path: AbsPath,
+  edits: import_zod6.z.array(
+    import_zod6.z.strictObject({
+      old_text: import_zod6.z.string(),
+      new_text: import_zod6.z.string(),
+      replace_all: import_zod6.z.boolean().default(false)
+    })
+  ).min(1).max(256),
+  create_if_missing: import_zod6.z.boolean().default(false)
+});
+var FsPatchResult = import_zod6.z.strictObject({ path: AbsPath, applied: nonNegInt, size: nonNegInt, mtime_ms: epochMs });
+var FsSearchPathsParams = import_zod6.z.strictObject({
+  pattern: import_zod6.z.string().min(1).max(512),
+  cwd: AbsPath,
+  hidden: import_zod6.z.boolean().default(false),
+  max_results: import_zod6.z.int().min(1).max(5e3).default(100)
+});
+var FsSearchPathsResult = import_zod6.z.strictObject({ paths: import_zod6.z.array(AbsPath), truncated: import_zod6.z.boolean() });
+var FsSearchContentParams = import_zod6.z.strictObject({
+  query: import_zod6.z.string().min(1).max(1024),
+  cwd: AbsPath,
+  regex: import_zod6.z.boolean().default(true),
+  case_sensitive: import_zod6.z.boolean().default(false),
+  include: import_zod6.z.array(import_zod6.z.string().max(256)).max(64).optional(),
+  exclude: import_zod6.z.array(import_zod6.z.string().max(256)).max(64).optional(),
+  max_results: import_zod6.z.int().min(1).max(5e3).default(100)
+});
+var FsSearchContentResult = import_zod6.z.strictObject({
+  results: import_zod6.z.array(
+    import_zod6.z.strictObject({
+      path: AbsPath,
+      lines: import_zod6.z.string(),
+      line_number: import_zod6.z.int().min(1),
+      submatches: import_zod6.z.array(import_zod6.z.strictObject({ match: import_zod6.z.string(), start: nonNegInt, end: nonNegInt }))
+    })
+  ),
+  truncated: import_zod6.z.boolean()
+});
+var FsChange = import_zod6.z.strictObject({
+  type: import_zod6.z.enum(["created", "modified", "deleted", "moved"]),
+  path: AbsPath,
+  to_path: AbsPath.optional(),
+  kind: import_zod6.z.enum(["file", "dir", "symlink", "unknown"])
+});
+var FsChangedEvent = import_zod6.z.strictObject({ changes: import_zod6.z.array(FsChange).min(1).max(1e3), overflow: import_zod6.z.boolean() });
+
+// src/schema/exec.ts
+var import_zod7 = require("zod");
+var Signal = import_zod7.z.enum(["SIGINT", "SIGTERM", "SIGKILL", "SIGHUP", "SIGQUIT", "SIGTSTP", "SIGCONT", "SIGUSR1", "SIGUSR2"]);
+var cols = import_zod7.z.int().min(2).max(1e3);
+var rows = import_zod7.z.int().min(1).max(500);
+var ExecPtyStartParams = import_zod7.z.strictObject({
+  cols,
+  rows,
+  cwd: AbsPath.optional(),
+  // default: home
+  shell: import_zod7.z.string().max(512).optional(),
+  // default: user's login shell (PowerShell on Windows)
+  args: import_zod7.z.array(import_zod7.z.string().max(4096)).max(64).optional(),
+  env: import_zod7.z.record(import_zod7.z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(128), import_zod7.z.string().max(32768)).optional(),
+  name: import_zod7.z.string().max(64).optional(),
+  // tab label
+  window_bytes: import_zod7.z.int().min(4096).max(16777216).optional()
+});
+var PtyInfo = import_zod7.z.strictObject({
+  resource_id: ResourceId,
+  pid: import_zod7.z.int().min(1),
+  shell: import_zod7.z.string().max(512),
+  cwd: AbsPath,
+  // live, from OSC 7 / process cwd
+  title: import_zod7.z.string().max(256),
+  name: import_zod7.z.string().max(64).nullable(),
+  cols,
+  rows,
+  state: import_zod7.z.enum(["running", "exited"]),
+  exit_code: import_zod7.z.int().nullable(),
+  exit_signal: Signal.nullable(),
+  last_seq: u32,
+  created_at_ms: epochMs,
+  controller_client_id: import_zod7.z.string().max(64).nullable(),
+  // null = orphaned (in grace period)
+  attached_clients: nonNegInt,
+  orphan_expires_at_ms: epochMs.nullable()
+});
+var ExecPtyStartResult = PtyInfo;
+var ExecPtyWriteParams = import_zod7.z.strictObject({ resource_id: ResourceId, data: import_zod7.z.string().min(1).max(65536) });
+var ExecPtyWriteResult = import_zod7.z.strictObject({ written: nonNegInt });
+var ExecPtyResizeParams = import_zod7.z.strictObject({ resource_id: ResourceId, cols, rows });
+var ExecPtyResizeResult = import_zod7.z.strictObject({ cols, rows });
+var ExecPtySignalParams = import_zod7.z.strictObject({ resource_id: ResourceId, signal: Signal });
+var ExecPtySignalResult = import_zod7.z.strictObject({ delivered: import_zod7.z.boolean() });
+var ExecPtyKillParams = import_zod7.z.strictObject({ resource_id: ResourceId, grace_ms: import_zod7.z.int().min(0).max(3e4).default(2e3) });
+var ExecPtyKillResult = import_zod7.z.strictObject({ exit_code: import_zod7.z.int().nullable(), exit_signal: Signal.nullable() });
+var ExecListParams = import_zod7.z.strictObject({});
+var ExecListResult = import_zod7.z.strictObject({ sessions: import_zod7.z.array(PtyInfo) });
+var ExecRunParams = import_zod7.z.strictObject({
+  command: import_zod7.z.string().min(1).max(131072),
+  cwd: AbsPath.optional(),
+  cwd_key: import_zod7.z.string().max(128).optional(),
+  env: import_zod7.z.record(import_zod7.z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(128), import_zod7.z.string().max(32768)).optional(),
+  stdin: import_zod7.z.string().max(1048576).optional(),
+  timeout: import_zod7.z.int().min(1).max(3600).default(60),
+  // seconds, daemon parity
+  max_output_bytes: import_zod7.z.int().min(1024).max(8388608).default(1048576)
+});
+var ExecRunResult = import_zod7.z.strictObject({
+  exit_code: import_zod7.z.int(),
+  stdout: import_zod7.z.string(),
+  stderr: import_zod7.z.string(),
+  cwd: AbsPath,
+  duration_ms: nonNegInt,
+  timed_out: import_zod7.z.boolean(),
+  output_truncated: import_zod7.z.boolean()
+});
+var ExecExitedEvent = import_zod7.z.strictObject({ exit_code: import_zod7.z.int().nullable(), exit_signal: Signal.nullable() });
+var ExecTitleEvent = import_zod7.z.strictObject({ title: import_zod7.z.string().max(256) });
+var ExecCwdEvent = import_zod7.z.strictObject({ cwd: AbsPath });
+
+// src/schema/session.ts
+var import_zod8 = require("zod");
+var SessionAttachParams = import_zod8.z.strictObject({
+  resource_id: ResourceId,
+  mode: import_zod8.z.enum(["control", "read_only"]).default("control"),
+  since_seq: u32.optional(),
+  window_bytes: import_zod8.z.int().min(4096).max(16777216).optional()
+});
+var ResourceInfo = import_zod8.z.discriminatedUnion("kind", [
+  import_zod8.z.strictObject({ kind: import_zod8.z.literal("pty"), pty: PtyInfo }),
+  import_zod8.z.strictObject({
+    kind: import_zod8.z.literal("watch"),
+    resource_id: ResourceId,
+    path: AbsPath,
+    orphan_expires_at_ms: epochMs.nullable()
+  })
+]);
+var SessionAttachResult = ResourceInfo;
+var SessionDetachParams = import_zod8.z.strictObject({ resource_id: ResourceId });
+var SessionDetachResult = import_zod8.z.strictObject({ orphan_expires_at_ms: epochMs.nullable() });
+var SessionReleaseParams = import_zod8.z.strictObject({ resource_id: ResourceId });
+var SessionReleaseResult = import_zod8.z.strictObject({ released: import_zod8.z.literal(true) });
+var SessionListParams = import_zod8.z.strictObject({});
+var SessionListResult = import_zod8.z.strictObject({ resources: import_zod8.z.array(ResourceInfo) });
+var SessionControlChangedEvent = import_zod8.z.strictObject({ controller_client_id: import_zod8.z.string().max(64).nullable(), your_mode: import_zod8.z.enum(["control", "read_only"]) });
+
+// src/schema/relay.ts
+var import_zod9 = require("zod");
+var RelayDeviceStatusEvent = import_zod9.z.strictObject({
+  online: import_zod9.z.boolean(),
+  since_ms: epochMs,
+  app_version: import_zod9.z.string().max(32).nullable(),
+  protocol_version: ProtocolVersion.nullable()
+});
+var RelayAuthExpiringEvent = import_zod9.z.strictObject({ expires_at_ms: epochMs });
+var RelayCallRequest = import_zod9.z.strictObject({
+  cap: import_zod9.z.string().min(1).max(32),
+  op: import_zod9.z.string().min(1).max(64),
+  params: import_zod9.z.unknown(),
+  timeout_ms: import_zod9.z.int().min(100).max(37e5).default(7e4)
+});
+var RelayCallResponse = import_zod9.z.discriminatedUnion("ok", [
+  import_zod9.z.strictObject({ ok: import_zod9.z.literal(true), result: import_zod9.z.unknown() }),
+  import_zod9.z.strictObject({ ok: import_zod9.z.literal(false), error: ProtocolErrorBody })
+]);
+
+// src/schema/registry.ts
+var FS_ERR = ["NOT_FOUND", "PERMISSION_DENIED_OS", "INVALID_PARAMS", "RESOURCE_BUSY", "INTERNAL"];
+var OPS = {
+  "sysinfo.get": { params: SysinfoGetParams, result: SysinfoGetResult, kind: "unary", since: "1.0", errors: ["INTERNAL"] },
+  "fs.list": { params: FsListParams, result: FsListResult, kind: "unary", since: "1.0", errors: FS_ERR },
+  "fs.stat": { params: FsStatParams, result: FsStatResult, kind: "unary", since: "1.0", errors: FS_ERR },
+  "fs.read": { params: FsReadParams, result: FsReadResult, kind: "unary", since: "1.0", errors: [...FS_ERR, "PAYLOAD_TOO_LARGE"] },
+  "fs.read_stream": { params: FsReadStreamParams, result: FsReadStreamResult, kind: "stream", since: "1.0", errors: [...FS_ERR, "CANCELLED"] },
+  "fs.write": { params: FsWriteParams, result: FsWriteResult, kind: "unary", since: "1.0", errors: [...FS_ERR, "CONFLICT", "PAYLOAD_TOO_LARGE"] },
+  "fs.mkdir": { params: FsMkdirParams, result: FsMkdirResult, kind: "unary", since: "1.0", errors: [...FS_ERR, "CONFLICT"] },
+  "fs.move": { params: FsMoveParams, result: FsMoveResult, kind: "unary", since: "1.0", errors: [...FS_ERR, "CONFLICT"] },
+  "fs.delete": { params: FsDeleteParams, result: FsDeleteResult, kind: "unary", since: "1.0", errors: FS_ERR },
+  "fs.watch": { params: FsWatchParams, result: FsWatchResult, kind: "resource", since: "1.0", errors: [...FS_ERR, "RATE_LIMITED"] },
+  "fs.patch": { params: FsPatchParams, result: FsPatchResult, kind: "unary", since: "1.0", errors: [...FS_ERR, "CONFLICT"] },
+  "fs.search_paths": { params: FsSearchPathsParams, result: FsSearchPathsResult, kind: "unary", since: "1.0", errors: [...FS_ERR, "TIMEOUT"] },
+  "fs.search_content": { params: FsSearchContentParams, result: FsSearchContentResult, kind: "unary", since: "1.0", errors: [...FS_ERR, "TIMEOUT"] },
+  "exec.pty.start": { params: ExecPtyStartParams, result: ExecPtyStartResult, kind: "resource", since: "1.0", errors: ["INVALID_PARAMS", "NOT_FOUND", "RATE_LIMITED", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "exec.pty.write": { params: ExecPtyWriteParams, result: ExecPtyWriteResult, kind: "unary", since: "1.0", errors: ["RESOURCE_GONE", "AUTH_FORBIDDEN", "INVALID_PARAMS"] },
+  "exec.pty.resize": { params: ExecPtyResizeParams, result: ExecPtyResizeResult, kind: "unary", since: "1.0", errors: ["RESOURCE_GONE", "AUTH_FORBIDDEN"] },
+  "exec.pty.signal": { params: ExecPtySignalParams, result: ExecPtySignalResult, kind: "unary", since: "1.0", errors: ["RESOURCE_GONE", "AUTH_FORBIDDEN", "PLATFORM_UNSUPPORTED"] },
+  "exec.pty.kill": { params: ExecPtyKillParams, result: ExecPtyKillResult, kind: "unary", since: "1.0", errors: ["RESOURCE_GONE", "AUTH_FORBIDDEN"] },
+  "exec.list": { params: ExecListParams, result: ExecListResult, kind: "unary", since: "1.0", errors: ["INTERNAL"] },
+  "exec.run": { params: ExecRunParams, result: ExecRunResult, kind: "unary", since: "1.0", errors: ["INVALID_PARAMS", "NOT_FOUND", "TIMEOUT", "CANCELLED", "INTERNAL"] },
+  "session.attach": { params: SessionAttachParams, result: SessionAttachResult, kind: "stream", since: "1.0", errors: ["RESOURCE_GONE", "AUTH_FORBIDDEN", "RESOURCE_BUSY"] },
+  "session.detach": { params: SessionDetachParams, result: SessionDetachResult, kind: "unary", since: "1.0", errors: ["RESOURCE_GONE"] },
+  "session.release": { params: SessionReleaseParams, result: SessionReleaseResult, kind: "unary", since: "1.0", errors: ["RESOURCE_GONE", "AUTH_FORBIDDEN"] },
+  "session.list": { params: SessionListParams, result: SessionListResult, kind: "unary", since: "1.0", errors: ["INTERNAL"] }
+};
+var EVENTS = {
+  "fs.changed": FsChangedEvent,
+  "exec.exited": ExecExitedEvent,
+  "exec.title": ExecTitleEvent,
+  "exec.cwd": ExecCwdEvent,
+  "session.control_changed": SessionControlChangedEvent,
+  "relay.device_status": RelayDeviceStatusEvent,
+  "relay.auth_expiring": RelayAuthExpiringEvent
+};
+
+// src/client/client.ts
+var WS_OPEN = 1;
+var TERMINAL_CLOSE = /* @__PURE__ */ new Map([
+  [CloseCode.DEVICE_REVOKED, ["AUTH_DEVICE_REVOKED", "This device was revoked"]],
+  [CloseCode.AUTH_FORBIDDEN, ["AUTH_FORBIDDEN", "Not this device's owner"]],
+  [CloseCode.DEVICE_NOT_FOUND, ["NOT_FOUND", "Device not found"]],
+  [CloseCode.REPLACED, ["CONFLICT", "Replaced by a newer connection"]],
+  [CloseCode.UPGRADE_REQUIRED, ["PROTOCOL_VERSION_UNSUPPORTED", "Protocol upgrade required"]]
+]);
+var defaultTimers = {
+  setTimeout: (fn, ms) => globalThis.setTimeout(fn, ms),
+  clearTimeout: (handle) => globalThis.clearTimeout(handle),
+  now: () => Date.now()
+};
+function defaultWebSocket() {
+  return (url, protocols) => {
+    const Ctor = globalThis.WebSocket;
+    if (!Ctor) {
+      throw new DesktopProtocolError("PLATFORM_UNSUPPORTED", "No global WebSocket \u2014 pass options.webSocket");
+    }
+    return new Ctor(url, protocols);
+  };
+}
+function capOf(op) {
+  const dot = op.indexOf(".");
+  return { cap: op.slice(0, dot), op: op.slice(dot + 1) };
+}
+function fromBody(body) {
+  return body.data === void 0 ? new DesktopProtocolError(body.code, body.message, { retryable: body.retryable }) : new DesktopProtocolError(body.code, body.message, { retryable: body.retryable, data: body.data });
+}
+function toBytes(data) {
+  if (data instanceof ArrayBuffer) return new Uint8Array(data);
+  if (ArrayBuffer.isView(data)) return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+  return null;
+}
+function createDesktopClient(options) {
+  const timers = options.timers ?? defaultTimers;
+  const makeSocket = options.webSocket ?? defaultWebSocket();
+  const heartbeatMs = options.heartbeatMs ?? 25e3;
+  const requestTimeoutMs = options.requestTimeoutMs ?? 7e4;
+  const protocolVersion = options.protocolVersion ?? `${PROTOCOL_MAJOR}.${PROTOCOL_MINOR}`;
+  const backoff = (0, import_realtime.createBackoff)({ ...options.backoff, now: timers.now });
+  const diagnose = options.onDiagnostic ?? ((d) => {
+    console.warn("[desktop-protocol]", d.kind, d);
+  });
+  let state = {
+    status: "idle",
+    welcome: null,
+    attempts: 0,
+    retryInMs: null,
+    lastError: null,
+    lastCloseCode: null
+  };
+  const listeners = /* @__PURE__ */ new Set();
+  const readyWaiters = /* @__PURE__ */ new Set();
+  const pending = /* @__PURE__ */ new Map();
+  const streams = /* @__PURE__ */ new Map();
+  const bySid = /* @__PURE__ */ new Map();
+  const eventHandlers = /* @__PURE__ */ new Map();
+  let socket = null;
+  let socketGeneration = 0;
+  let nextId = 0;
+  let helloId = null;
+  let reconnectTimer = null;
+  let heartbeatTimer = null;
+  let lastHeardAt = 0;
+  let closedByUser = false;
+  const newId = (prefix) => `${prefix}${(++nextId).toString(36)}`;
+  function setState(patch) {
+    state = { ...state, ...patch };
+    for (const listener of [...listeners]) {
+      try {
+        listener();
+      } catch (error) {
+        diagnose({ kind: "handler_threw", where: "subscribe listener", error });
+      }
+    }
+  }
+  function sendJson(message) {
+    if (!socket || socket.readyState !== WS_OPEN) return false;
+    socket.send(JSON.stringify(message));
+    return true;
+  }
+  function connect() {
+    if (state.status === "connecting" || state.status === "handshaking" || state.status === "open") return;
+    closedByUser = false;
+    if (reconnectTimer !== null) {
+      timers.clearTimeout(reconnectTimer);
+      reconnectTimer = null;
+    }
+    void openSocket();
+  }
+  async function openSocket() {
+    const generation = ++socketGeneration;
+    setState({ status: "connecting", retryInMs: null });
+    let ws;
+    try {
+      const url = typeof options.url === "function" ? await options.url() : options.url;
+      const protocols = options.protocols ? await options.protocols() : [];
+      if (generation !== socketGeneration || closedByUser) return;
+      ws = makeSocket(url, protocols);
+    } catch (error) {
+      if (generation !== socketGeneration) return;
+      const err = error instanceof DesktopProtocolError ? error : new DesktopProtocolError("INTERNAL", "Could not open the connection", { retryable: true, cause: error });
+      onSocketGone(generation, null, err);
+      return;
+    }
+    socket = ws;
+    ws.binaryType = "arraybuffer";
+    ws.onopen = () => {
+      if (generation !== socketGeneration) return;
+      lastHeardAt = timers.now();
+      helloId = newId("h");
+      setState({ status: "handshaking" });
+      sendJson({ type: "hello", id: helloId, protocolVersion, clientType: options.clientType, clientVersion: options.clientVersion });
+      scheduleHeartbeat(generation);
+    };
+    ws.onmessage = (event) => {
+      if (generation !== socketGeneration) return;
+      lastHeardAt = timers.now();
+      onMessage(event.data);
+    };
+    ws.onerror = () => {
+    };
+    ws.onclose = (event) => {
+      if (generation !== socketGeneration) return;
+      onSocketGone(generation, event.code, null);
+    };
+  }
+  function scheduleHeartbeat(generation) {
+    if (heartbeatTimer !== null) timers.clearTimeout(heartbeatTimer);
+    heartbeatTimer = timers.setTimeout(() => {
+      heartbeatTimer = null;
+      if (generation !== socketGeneration || !socket) return;
+      const silentMs = timers.now() - lastHeardAt;
+      if (silentMs >= heartbeatMs * 2) {
+        diagnose({ kind: "heartbeat_timeout", silentMs });
+        const dead = socket;
+        onSocketGone(generation, null, new DesktopProtocolError("TIMEOUT", "Connection went silent", { retryable: true }));
+        try {
+          dead.close(CloseCode.NORMAL, "heartbeat timeout");
+        } catch {
+        }
+        return;
+      }
+      if (socket.readyState === WS_OPEN) socket.send(PING_TEXT);
+      scheduleHeartbeat(generation);
+    }, heartbeatMs);
+  }
+  function onSocketGone(generation, code, error) {
+    if (generation !== socketGeneration) return;
+    socketGeneration++;
+    if (socket) {
+      socket.onopen = socket.onmessage = socket.onclose = socket.onerror = null;
+    }
+    socket = null;
+    helloId = null;
+    if (heartbeatTimer !== null) {
+      timers.clearTimeout(heartbeatTimer);
+      heartbeatTimer = null;
+    }
+    const terminal = code === null ? void 0 : TERMINAL_CLOSE.get(code);
+    const lost = error ?? (terminal ? new DesktopProtocolError(terminal[0], terminal[1]) : new DesktopProtocolError("DEVICE_OFFLINE", "Connection lost", { retryable: true }));
+    for (const [id, p] of pending) {
+      pending.delete(id);
+      p.cleanup();
+      p.reject(lost);
+    }
+    bySid.clear();
+    for (const [id, s] of streams) {
+      if (s.resourceId !== null && terminal === void 0 && !closedByUser) {
+        s.sid = null;
+        s.reattaching = false;
+        continue;
+      }
+      streams.delete(id);
+      endStream(s, null, lost);
+    }
+    if (closedByUser || terminal) {
+      setState({ status: "closed", welcome: null, lastError: closedByUser ? state.lastError : lost, lastCloseCode: code, retryInMs: null });
+      rejectReadyWaiters(lost);
+      return;
+    }
+    const delay = backoff.nextDelayMs();
+    if (backoff.isAlarming()) diagnose({ kind: "reconnect_alarm", attempts: backoff.attempts() });
+    setState({ status: "reconnecting", welcome: null, attempts: backoff.attempts(), retryInMs: delay, lastError: lost, lastCloseCode: code });
+    reconnectTimer = timers.setTimeout(() => {
+      reconnectTimer = null;
+      if (!closedByUser) void openSocket();
+    }, delay);
+  }
+  function rejectReadyWaiters(error) {
+    for (const w of [...readyWaiters]) {
+      readyWaiters.delete(w);
+      w.reject(error);
+    }
+  }
+  function close() {
+    closedByUser = true;
+    if (reconnectTimer !== null) {
+      timers.clearTimeout(reconnectTimer);
+      reconnectTimer = null;
+    }
+    const cancelled = new DesktopProtocolError("CANCELLED", "Client closed");
+    const ws = socket;
+    if (ws) {
+      onSocketGone(socketGeneration, CloseCode.NORMAL, cancelled);
+      try {
+        ws.close(CloseCode.NORMAL, "client closed");
+      } catch {
+      }
+    } else {
+      for (const [id, s] of streams) {
+        streams.delete(id);
+        endStream(s, null, cancelled);
+      }
+      setState({ status: "closed", retryInMs: null });
+      rejectReadyWaiters(cancelled);
+    }
+  }
+  function onMessage(data) {
+    if (typeof data === "string") {
+      if (data === PONG_TEXT) return;
+      let json;
+      try {
+        json = JSON.parse(data);
+      } catch {
+        diagnose({ kind: "malformed_message", detail: "not JSON" });
+        return;
+      }
+      const parsed = CoreToClientMsg.safeParse(json);
+      if (!parsed.success) {
+        diagnose({ kind: "malformed_message", detail: parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ") });
+        return;
+      }
+      onEnvelope(parsed.data);
+      return;
+    }
+    const bytes = toBytes(data);
+    if (bytes === null) {
+      diagnose({ kind: "malformed_message", detail: "binary message is not an ArrayBuffer/view (set binaryType)" });
+      return;
+    }
+    let frame;
+    try {
+      frame = decodeFrame(bytes);
+    } catch (error) {
+      diagnose({ kind: "malformed_message", detail: error instanceof Error ? error.message : String(error) });
+      return;
+    }
+    onFrame(frame.header, frame.payload);
+  }
+  function onEnvelope(msg) {
+    switch (msg.type) {
+      case "response": {
+        if (msg.id === helloId) return onWelcome(msg.result);
+        const s = streams.get(msg.id);
+        if (s) return onStreamResult(s, msg.result);
+        const p = pending.get(msg.id);
+        if (!p) return diagnose({ kind: "unknown_request", id: msg.id, type: msg.type });
+        pending.delete(msg.id);
+        p.cleanup();
+        p.resolve(msg.result);
+        return;
+      }
+      case "error": {
+        const error = fromBody(msg.error);
+        if (msg.id === helloId) return onHelloRefused(error);
+        const s = streams.get(msg.id);
+        if (s) {
+          if (s.reattaching && s.resourceId !== null) diagnose({ kind: "reattach_failed", resourceId: s.resourceId, error });
+          streams.delete(msg.id);
+          if (s.sid !== null) bySid.delete(s.sid);
+          return endStream(s, null, error);
+        }
+        const p = pending.get(msg.id);
+        if (!p) return diagnose({ kind: "unknown_request", id: msg.id, type: msg.type });
+        pending.delete(msg.id);
+        p.cleanup();
+        p.reject(error);
+        return;
+      }
+      case "stream": {
+        const s = streams.get(msg.id);
+        if (!s) return diagnose({ kind: "unknown_request", id: msg.id, type: msg.type });
+        onStreamMeta(s, msg.meta);
+        return;
+      }
+      case "end": {
+        const s = streams.get(msg.id);
+        if (!s) return diagnose({ kind: "unknown_request", id: msg.id, type: msg.type });
+        void s.chain.then(() => {
+          streams.delete(s.id);
+          if (s.sid !== null) bySid.delete(s.sid);
+          endStream(s, msg.reason ?? "completed", null);
+        });
+        return;
+      }
+      case "credit": {
+        const s = streams.get(msg.id);
+        if (!s) return diagnose({ kind: "unknown_request", id: msg.id, type: msg.type });
+        s.sendWindow += msg.n;
+        flushSend(s);
+        return;
+      }
+      case "event": {
+        const key = `${msg.cap}.${msg.name}`;
+        const schema = EVENTS[key];
+        if (!schema) return diagnose({ kind: "malformed_message", detail: `unknown event ${key}` });
+        const payload = schema.safeParse(msg.payload);
+        if (!payload.success) return diagnose({ kind: "malformed_message", detail: `event ${key}: invalid payload` });
+        if (key === "relay.auth_expiring" && options.getToken) {
+          options.getToken().then(reauth, (error) => diagnose({ kind: "reauth_failed", error }));
+        }
+        for (const handler of [...eventHandlers.get(key) ?? []]) {
+          try {
+            handler(payload.data, msg.resourceId);
+          } catch (error) {
+            diagnose({ kind: "handler_threw", where: `event ${key}`, error });
+          }
+        }
+        return;
+      }
+    }
+  }
+  function onWelcome(result) {
+    const welcome = Welcome.safeParse(result);
+    if (!welcome.success) {
+      onHelloRefused(new DesktopProtocolError("PROTOCOL_ERROR", "Malformed welcome"));
+      return;
+    }
+    helloId = null;
+    backoff.markConnected();
+    setState({ status: "open", welcome: welcome.data, attempts: 0, retryInMs: null, lastError: null });
+    for (const w of [...readyWaiters]) {
+      readyWaiters.delete(w);
+      w.resolve(welcome.data);
+    }
+    for (const s of [...streams.values()]) {
+      if (s.sid === null && s.resourceId !== null && !s.ended) reattach(s, welcome.data);
+    }
+  }
+  function onHelloRefused(error) {
+    const ws = socket;
+    onSocketGone(socketGeneration, error.code === "PROTOCOL_VERSION_UNSUPPORTED" ? CloseCode.UPGRADE_REQUIRED : null, error);
+    try {
+      ws?.close(CloseCode.NORMAL, "hello refused");
+    } catch {
+    }
+  }
+  function onStreamResult(s, result) {
+    if (s.reattaching) {
+      s.reattaching = false;
+      safeCall("onReattached", () => s.handlers.onReattached?.());
+      return;
+    }
+    const rid = result?.resource_id;
+    if (typeof rid === "string") s.resourceId = rid;
+    if (!s.resultSettled) {
+      s.resultSettled = true;
+      s.resolveResult(result);
+    }
+  }
+  function onStreamMeta(s, meta) {
+    if (meta.kind === "open") {
+      if (s.sid !== null) bySid.delete(s.sid);
+      s.sid = meta.sid;
+      s.windowBytes = meta.window_bytes;
+      if (meta.resource_id !== void 0) s.resourceId = meta.resource_id;
+      bySid.set(meta.sid, s);
+      flushSend(s);
+    } else {
+      s.expectSeq = null;
+    }
+    safeCall("onMeta", () => s.handlers.onMeta?.(meta));
+  }
+  function onFrame(header, payload) {
+    const s = bySid.get(header.sid);
+    if (!s) {
+      diagnose({ kind: "unknown_stream", sid: header.sid });
+      return;
+    }
+    const isData = header.channel === FrameChannel.DATA || header.channel === FrameChannel.STDERR;
+    const isSnapshot = header.channel === FrameChannel.SNAPSHOT;
+    if (!isData && !isSnapshot) {
+      diagnose({ kind: "malformed_message", detail: `channel ${header.channel} is not client-bound` });
+      return;
+    }
+    if (isData) {
+      if (s.expectSeq !== null && header.seq !== s.expectSeq) {
+        diagnose({ kind: "seq_gap", id: s.id, expected: s.expectSeq, received: header.seq });
+      }
+      s.expectSeq = header.seq + 1;
+    }
+    const bytes = payload.slice();
+    const handler = isData ? s.handlers.onData : s.handlers.onSnapshot;
+    s.chain = s.chain.then(async () => {
+      if (s.ended) return;
+      try {
+        await handler?.(bytes, header);
+      } catch (error) {
+        diagnose({ kind: "handler_threw", where: isData ? "onData" : "onSnapshot", error });
+      }
+      if (isData) s.lastSeq = header.seq;
+      grantCredit(s, bytes.byteLength);
+    });
+  }
+  function grantCredit(s, consumed) {
+    s.consumedUncredited += consumed;
+    if (s.consumedUncredited >= Math.max(1, Math.floor(s.windowBytes / 4))) {
+      if (sendJson({ type: "credit", id: s.id, n: s.consumedUncredited })) s.consumedUncredited = 0;
+    }
+  }
+  function flushSend(s) {
+    if (s.sid === null || !socket || socket.readyState !== WS_OPEN) return;
+    const maxPayload = state.welcome?.limits.max_frame_payload_bytes ?? DEFAULT_MAX_FRAME_PAYLOAD_BYTES;
+    while (s.sendQueue.length > 0 && s.sendWindow > 0) {
+      const head = s.sendQueue[0];
+      const n = Math.min(head.byteLength, s.sendWindow, maxPayload);
+      const chunk = head.subarray(0, n);
+      if (n === head.byteLength) s.sendQueue.shift();
+      else s.sendQueue[0] = head.subarray(n);
+      s.sendWindow -= n;
+      s.sendSeq += 1;
+      socket.send(encodeFrame({ version: FRAME_VERSION, flags: 0, channel: FrameChannel.STDIN, cid: 0, sid: s.sid, seq: s.sendSeq }, chunk));
+    }
+  }
+  function endStream(s, reason, error) {
+    if (s.ended) return;
+    s.ended = true;
+    s.sendQueue = [];
+    if (!s.resultSettled) {
+      s.resultSettled = true;
+      s.rejectResult(error ?? new DesktopProtocolError("INTERNAL", "Stream ended before its result"));
+    }
+    if (error) s.rejectDone(error);
+    else s.resolveDone(reason ?? "completed");
+  }
+  function reattach(s, welcome) {
+    const id = newId("a");
+    streams.delete(s.id);
+    s.id = id;
+    s.reattaching = true;
+    s.expectSeq = s.lastSeq > 0 ? s.lastSeq + 1 : null;
+    s.consumedUncredited = 0;
+    s.sendWindow = welcome.limits.default_window_bytes;
+    s.sendSeq = 0;
+    streams.set(id, s);
+    const params = { resource_id: s.resourceId, mode: s.options.mode ?? "control" };
+    if (s.lastSeq > 0) params.since_seq = s.lastSeq;
+    if (s.options.windowBytes !== void 0) params.window_bytes = s.options.windowBytes;
+    sendJson({ id, type: "request", cap: "session", op: "attach", params });
+  }
+  function safeCall(where, fn) {
+    try {
+      fn();
+    } catch (error) {
+      diagnose({ kind: "handler_threw", where, error });
+    }
+  }
+  function ready(opts = {}) {
+    if (state.status === "open" && state.welcome) return Promise.resolve(state.welcome);
+    if (state.status === "closed") {
+      return Promise.reject(state.lastError ?? new DesktopProtocolError("CANCELLED", "Client is closed"));
+    }
+    if (state.status === "idle") connect();
+    return new Promise((resolve, reject) => {
+      const waiter = {
+        resolve: (w) => {
+          done();
+          resolve(w);
+        },
+        reject: (e) => {
+          done();
+          reject(e);
+        }
+      };
+      const timeoutMs = opts.timeoutMs ?? requestTimeoutMs;
+      const timer = timers.setTimeout(() => waiter.reject(new DesktopProtocolError("DEVICE_OFFLINE", "Device not reachable", { retryable: true })), timeoutMs);
+      const onAbort = () => waiter.reject(new DesktopProtocolError("CANCELLED", "Aborted"));
+      opts.signal?.addEventListener("abort", onAbort, { once: true });
+      function done() {
+        readyWaiters.delete(waiter);
+        timers.clearTimeout(timer);
+        opts.signal?.removeEventListener("abort", onAbort);
+      }
+      readyWaiters.add(waiter);
+    });
+  }
+  async function request(op, params, opts = {}) {
+    if (OPS[op].kind !== "unary") {
+      throw new DesktopProtocolError("INVALID_PARAMS", `${op} is a ${OPS[op].kind} op \u2014 use stream()`);
+    }
+    await ready(opts);
+    const id = newId("r");
+    return new Promise((resolve, reject) => {
+      const timeoutMs = opts.timeoutMs ?? requestTimeoutMs;
+      const timer = timers.setTimeout(() => {
+        pending.delete(id);
+        cleanup();
+        sendJson({ id, type: "cancel" });
+        reject(new DesktopProtocolError("TIMEOUT", `${op} timed out`, { retryable: true }));
+      }, timeoutMs);
+      const onAbort = () => {
+        pending.delete(id);
+        cleanup();
+        sendJson({ id, type: "cancel" });
+        reject(new DesktopProtocolError("CANCELLED", "Aborted"));
+      };
+      function cleanup() {
+        timers.clearTimeout(timer);
+        opts.signal?.removeEventListener("abort", onAbort);
+      }
+      opts.signal?.addEventListener("abort", onAbort, { once: true });
+      pending.set(id, { kind: "unary", op, resolve, reject, cleanup });
+      if (!sendJson({ id, type: "request", ...capOf(op), params })) {
+        pending.delete(id);
+        cleanup();
+        reject(new DesktopProtocolError("DEVICE_OFFLINE", "Connection lost", { retryable: true }));
+      }
+    });
+  }
+  function stream(op, params, handlers = {}, opts = {}) {
+    let resolveResult;
+    let rejectResult;
+    let resolveDone;
+    let rejectDone;
+    const result = new Promise((res, rej) => {
+      resolveResult = res;
+      rejectResult = rej;
+    });
+    const done = new Promise((res, rej) => {
+      resolveDone = res;
+      rejectDone = rej;
+    });
+    result.catch(() => void 0);
+    done.catch(() => void 0);
+    const s = {
+      op,
+      handlers,
+      options: opts,
+      id: newId("s"),
+      sid: null,
+      resourceId: null,
+      lastSeq: 0,
+      expectSeq: 1,
+      windowBytes: opts.windowBytes ?? DEFAULT_WINDOW_BYTES,
+      consumedUncredited: 0,
+      sendWindow: DEFAULT_WINDOW_BYTES,
+      sendSeq: 0,
+      sendQueue: [],
+      chain: Promise.resolve(),
+      resultSettled: false,
+      resolveResult,
+      rejectResult,
+      resolveDone,
+      rejectDone,
+      ended: false,
+      reattaching: false
+    };
+    const start = async () => {
+      let welcome;
+      try {
+        welcome = await ready(opts);
+      } catch (error) {
+        endStream(s, null, error);
+        return;
+      }
+      if (s.ended) return;
+      s.sendWindow = welcome.limits.default_window_bytes;
+      if (opts.windowBytes === void 0) s.windowBytes = welcome.limits.default_window_bytes;
+      streams.set(s.id, s);
+      const wire = { ...params };
+      if (opts.windowBytes !== void 0 && "window_bytes" in OPS[op].params.shape) wire.window_bytes = opts.windowBytes;
+      if (!sendJson({ id: s.id, type: "request", ...capOf(op), params: wire })) {
+        streams.delete(s.id);
+        endStream(s, null, new DesktopProtocolError("DEVICE_OFFLINE", "Connection lost", { retryable: true }));
+      }
+    };
+    void start();
+    opts.signal?.addEventListener("abort", () => handle.cancel(), { once: true });
+    const encoder = new TextEncoder();
+    const handle = {
+      get id() {
+        return s.id;
+      },
+      result,
+      done,
+      get resourceId() {
+        return s.resourceId;
+      },
+      get lastSeq() {
+        return s.lastSeq;
+      },
+      write(data) {
+        if (s.ended) throw new DesktopProtocolError("RESOURCE_GONE", "Stream has ended");
+        const bytes = typeof data === "string" ? encoder.encode(data) : data;
+        if (bytes.byteLength === 0) return;
+        s.sendQueue.push(bytes);
+        flushSend(s);
+      },
+      cancel() {
+        if (s.ended) return;
+        if (!sendJson({ id: s.id, type: "cancel" })) {
+          streams.delete(s.id);
+          endStream(s, "cancelled", null);
+        }
+      },
+      async detach() {
+        if (s.ended) return;
+        if (s.resourceId === null) throw new DesktopProtocolError("INVALID_PARAMS", "Only resource streams can be detached");
+        const resourceId = s.resourceId;
+        streams.delete(s.id);
+        if (s.sid !== null) bySid.delete(s.sid);
+        endStream(s, "detached", null);
+        await request("session.detach", { resource_id: resourceId });
+      }
+    };
+    return handle;
+  }
+  function on(name, handler) {
+    let set = eventHandlers.get(name);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      eventHandlers.set(name, set);
+    }
+    set.add(handler);
+    return () => {
+      set.delete(handler);
+    };
+  }
+  function reauth(token) {
+    sendJson({ type: "relay", op: "reauth", token });
+  }
+  return {
+    connect,
+    close,
+    getState: () => state,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    ready,
+    request,
+    stream,
+    on,
+    reauth
+  };
+}
+//# sourceMappingURL=client.cjs.map