@unbound-app/debugger-protocol 2.0.1 → 2.1.1

package/dist/index-CxErH5OQ.d.mts

@@ -0,0 +1,768 @@
+import { PushedManifest } from "@unbound-app/types";
+/**
+ * The object explorer's frames: a controller asks the device for a native object's class chain, one page of one kind
+ * of a class's members, the values of the members on screen, and (iOS) the loaded images and their classes.
+ */
+/** The most members a device returns for one {@link ExplorerMembersRequest}. */
+declare const EXPLORER_MEMBERS_PAGE_SIZE = 100;
+/** The most images or class names a device returns for one {@link ExplorerClassesRequest}. */
+declare const EXPLORER_CLASSES_PAGE_SIZE = 200;
+/** The most member values one {@link ExplorerValuesRequest} may name. */
+declare const EXPLORER_VALUES_LIMIT = 50;
+/** A kind of class member: the first five are Objective-C's, `fields` to `interfaces` Java's, `methods` both. */
+type ExplorerMemberKind = 'properties' | 'ivars' | 'methods' | 'classMethods' | 'protocols' | 'fields' | 'constructors' | 'interfaces';
+/** What to explore: a listed view, an object the explorer handed out a ref for, or a class by name. */
+type ExplorerTarget = {
+  node: string;
+} | {
+  object: string;
+} | {
+  className: string;
+};
+/** One class of an object's chain, with how many members of each kind it declares itself. */
+type ExplorerClass = {
+  name: string;
+  /** The binary image that defines the class, or `null` when unknown, as on Android. */
+  image: string | null;
+  /** The size of an instance in bytes, or `null` when unknown. */
+  instanceSize: number | null;
+  counts: Partial<Record<ExplorerMemberKind, number>>;
+};
+/** One member a class declares. */
+type ExplorerMember = {
+  name: string;
+  kind: ExplorerMemberKind;
+  /** The decoded type of a property, ivar or field, or a method's return type. */
+  type: string | null;
+  /** A declaration to show, such as `- (void)setFoo:(id)foo`. */
+  signature: string | null;
+  returnType?: string;
+  parameters?: string[];
+  /** Property attributes such as `nonatomic`, `strong` or `readonly`. */
+  attributes?: string[];
+  static?: boolean;
+  offset?: number;
+  size?: number;
+  image?: string | null;
+  /** Whether a value read is automatic and safe, runs code so needs a click, or is never made. */
+  read: 'auto' | 'manual' | 'never';
+};
+/** How a member's value reads: a value kind, `skipped` when unsafe to read, or `error`. */
+type ExplorerValueKind = 'nil' | 'number' | 'bool' | 'string' | 'object' | 'class' | 'struct' | 'pointer' | 'selector' | 'other' | 'skipped' | 'error';
+/** One member's value, read on the device. */
+type ExplorerValue = {
+  name: string;
+  kind: ExplorerValueKind;
+  text: string;
+  /** The ref to open an object value with, as an `{ object }` target. */
+  object?: string;
+  className?: string;
+};
+/** A native object, or a class alone when `ref` is `null`. */
+type ExplorerObject = {
+  /** The device's ref for the object, `<epoch>:<n>`, valid until the debugger reconnects or JavaScript reloads. */
+  ref: string | null;
+  className: string;
+  description: string | null;
+  platform: 'ios' | 'android';
+  /** The class, then each superclass up to the root. */
+  chain: ExplorerClass[];
+};
+/** Why an explorer request failed, so the controller can fall back or explain. */
+type ExplorerErrorCode =
+/** The ref or node is gone, such as after a JavaScript reload. */
+'stale' |
+/** Developer mode and the debugger are both off. */
+'disabled' |
+/** The inspector failed to load. */
+'unavailable' |
+/** The loader or platform cannot answer this request. */
+'unsupported' | 'unknown-class' | 'failed';
+/** A failed explorer answer. */
+type ExplorerError = {
+  ok: false;
+  error: string;
+  code: ExplorerErrorCode;
+};
+/** A loaded binary image that defines Objective-C classes. */
+type ExplorerImage = {
+  path: string;
+  name: string;
+  classCount: number;
+};
+/** Controller → bridge → device: read an object's class chain. */
+type ExplorerObjectRequest = {
+  type: 'explorer-object-request';
+  /** Correlation id echoed back on the matching {@link ExplorerObjectResult}. */
+  id: string;
+  target: ExplorerTarget;
+};
+/** The answer to an {@link ExplorerObjectRequest}. */
+type ExplorerObjectResult = {
+  type: 'explorer-object-result';
+  id: string;
+} & ({
+  ok: true;
+  object: ExplorerObject;
+} | ExplorerError);
+/** Controller → bridge → device: list one page of one kind of the members a class declares. */
+type ExplorerMembersRequest = {
+  type: 'explorer-members-request';
+  id: string;
+  className: string;
+  kind: ExplorerMemberKind;
+  offset?: number;
+  /** At most {@link EXPLORER_MEMBERS_PAGE_SIZE}, which is also the default. */
+  limit?: number;
+  /** A case-insensitive substring of the member names to keep. */
+  filter?: string;
+};
+/** The answer to an {@link ExplorerMembersRequest}. */
+type ExplorerMembersResult = {
+  type: 'explorer-members-result';
+  id: string;
+} & ({
+  ok: true;
+  members: ExplorerMember[];
+  total: number;
+} | ExplorerError);
+/** Controller → bridge → device: read the named members of `className` on an object. */
+type ExplorerValuesRequest = {
+  type: 'explorer-values-request';
+  id: string;
+  /** The object's ref. */
+  object: string;
+  className: string;
+  kind: ExplorerMemberKind;
+  /** At most {@link EXPLORER_VALUES_LIMIT} names. */
+  names: string[];
+  /** Runs the getters of computed properties too. */
+  invokeGetters?: boolean;
+};
+/** The answer to an {@link ExplorerValuesRequest}. */
+type ExplorerValuesResult = {
+  type: 'explorer-values-result';
+  id: string;
+} & ({
+  ok: true;
+  values: ExplorerValue[];
+} | ExplorerError);
+/** Controller → bridge → device: list a page of the loaded images, or of one image's class names. */
+type ExplorerClassesRequest = {
+  type: 'explorer-classes-request';
+  id: string;
+  /** The image path whose classes to list; the images themselves when omitted. */
+  image?: string;
+  filter?: string;
+  offset?: number;
+  /** At most {@link EXPLORER_CLASSES_PAGE_SIZE}, which is also the default. */
+  limit?: number;
+};
+/** The answer to an {@link ExplorerClassesRequest}: `images` without an image, `classes` with one. */
+type ExplorerClassesResult = {
+  type: 'explorer-classes-result';
+  id: string;
+} & ({
+  ok: true;
+  total: number;
+  images?: ExplorerImage[];
+  classes?: string[];
+} | ExplorerError);
+type ExplorerRequest = ExplorerObjectRequest | ExplorerMembersRequest | ExplorerValuesRequest | ExplorerClassesRequest;
+type ExplorerResult = ExplorerObjectResult | ExplorerMembersResult | ExplorerValuesResult | ExplorerClassesResult;
+/** The result frame type answering each request frame type. */
+declare const EXPLORER_RESULT_TYPES: {
+  readonly 'explorer-object-request': 'explorer-object-result';
+  readonly 'explorer-members-request': 'explorer-members-result';
+  readonly 'explorer-values-request': 'explorer-values-result';
+  readonly 'explorer-classes-request': 'explorer-classes-result';
+};
+/** A frame narrowed to its type, before its other fields are checked. */
+type TypedFrame$1 = {
+  type: string;
+};
+/**
+ * @description Builds the failed answer to an explorer request.
+ * @param request The request, or its type and id.
+ * @param error What failed.
+ * @param code Why it failed.
+ * @returns The result frame.
+ */
+declare function failExplorerRequest(request: Pick<ExplorerRequest, 'type' | 'id'>, error: string, code: ExplorerErrorCode): ExplorerResult;
+/**
+ * @description Checks whether a frame is an explorer request, by its type alone.
+ * @param frame A parsed frame.
+ * @returns Whether it is one.
+ */
+declare function isExplorerRequest(frame: TypedFrame$1): frame is ExplorerRequest;
+/**
+ * @description Checks whether a frame is an explorer result, by its type alone.
+ * @param frame A parsed frame.
+ * @returns Whether it is one.
+ */
+declare function isExplorerResult(frame: TypedFrame$1): frame is ExplorerResult;
+/**
+ * The Metro explorer's frames: list, load and search modules, and walk a loaded module's exports as a tree. Long
+ * work runs in short device-side batches the controller repeats; getters run only when asked.
+ */
+/** The most modules a device returns for one {@link MetroModulesRequest}. */
+declare const METRO_MODULES_PAGE_SIZE = 200;
+/** The most properties a device returns for one {@link MetroChildrenRequest}. */
+declare const METRO_CHILDREN_PAGE_SIZE = 100;
+/** The most matches a device collects for one {@link MetroSearchRequest} before it stops at a module's end. */
+declare const METRO_SEARCH_PAGE_SIZE = 50;
+/** Whether a module's factory has run: `failed` when it threw, or searches skip it before it ran. */
+type MetroModuleStatus = 'loaded' | 'unloaded' | 'failed';
+/** One Metro module. */
+type MetroModule = {
+  id: number;
+  status: MetroModuleStatus;
+  /** A loaded module's file path, else its first export names; `null` before it loads or when it exports none. */
+  label: string | null;
+};
+/** What a value is, which picks its colour; `getter` is an accessor that has not run. */
+type MetroValueKind = 'string' | 'number' | 'boolean' | 'nullish' | 'symbol' | 'function' | 'class' | 'array' | 'object' | 'error' | 'getter';
+/** One value in the tree: a module's exports, a property, or a slot such as `[[Prototype]]`. */
+type MetroValue = {
+  key: string;
+  kind: MetroValueKind;
+  text: string;
+  /**
+   * The ref that lists the value's children, or that runs a getter. The same object always has the same ref, so a
+   * controller can tell a value that is already open above itself.
+   */
+  ref?: string;
+  /** An engine slot such as `[[Prototype]]` or `[[Entries]]` rather than a property. */
+  internal?: boolean;
+};
+/** What to list the children of: a loaded module's exports, or a value the device handed out a ref for. */
+type MetroTarget = {
+  module: number;
+} | {
+  ref: string;
+};
+/** Why a Metro request failed. */
+type MetroErrorCode =
+/** The ref is gone, such as after a JavaScript reload. */
+'stale' | 'unknown-module' |
+/** The module has not loaded, so it has no exports to list. */
+'unloaded' | 'failed';
+/** A failed Metro answer. */
+type MetroError = {
+  ok: false;
+  error: string;
+  code: MetroErrorCode;
+};
+/** Controller → bridge → device: list a page of the modules matching a filter and a status. */
+type MetroModulesRequest = {
+  type: 'metro-modules-request';
+  /** Correlation id echoed back on the matching {@link MetroModulesResult}. */
+  id: string;
+  /** A case-insensitive id prefix or substring of a module's label. */
+  filter?: string;
+  /** The status to keep; every module when omitted. */
+  status?: MetroModuleStatus;
+  offset?: number;
+  /** At most {@link METRO_MODULES_PAGE_SIZE}, which is also the default. */
+  limit?: number;
+};
+/** The answer to a {@link MetroModulesRequest}. */
+type MetroModulesResult = {
+  type: 'metro-modules-result';
+  id: string;
+} & ({
+  ok: true;
+  modules: MetroModule[];
+  /** How many modules match. */
+  total: number;
+  /** How many modules have loaded, of `count`. */
+  loaded: number;
+  /** How many modules the registry holds. */
+  count: number;
+} | MetroError);
+/** Controller → bridge → device: run a module's factory, and those of the modules it requires. */
+type MetroLoadRequest = {
+  type: 'metro-load-request';
+  id: string;
+  module: number;
+};
+/** The answer to a {@link MetroLoadRequest}: the module afterwards, `failed` when its factory threw. */
+type MetroLoadResult = {
+  type: 'metro-load-result';
+  id: string;
+} & ({
+  ok: true;
+  module: MetroModule;
+  loaded: number;
+} | MetroError);
+/**
+ * Controller → bridge → device: load the next batch of modules that have not loaded, skipping the blacklist of
+ * modules that threw or export something invalid. The controller repeats it until `remaining` is 0.
+ */
+type MetroLoadAllRequest = {
+  type: 'metro-load-all-request';
+  id: string;
+};
+/** The answer to a {@link MetroLoadAllRequest}: what the batch did and what is left. */
+type MetroLoadAllResult = {
+  type: 'metro-load-all-result';
+  id: string;
+} & ({
+  ok: true;
+  /** How many modules this batch ran. */
+  attempted: number;
+  /** How many of those threw, and joined the blacklist. */
+  failed: number;
+  /** How many modules are still to run; 0 when Load All is done. */
+  remaining: number;
+  loaded: number;
+  count: number;
+} | MetroError);
+/** One key a search matched: the module, the keys from its exports down to it, and its value. */
+type MetroMatch = {
+  module: MetroModule;
+  /** Property keys, or `[[Prototype]]`, from the exports; empty when the exports themselves match. */
+  path: string[];
+  value: MetroValue;
+};
+/**
+ * Controller → bridge → device: find keys containing `query` under the loaded modules' exports and prototypes,
+ * without running getters, for one batch; the answer's `cursor` continues it.
+ */
+type MetroSearchRequest = {
+  type: 'metro-search-request';
+  id: string;
+  /** Case-insensitive text a key or function name contains. */
+  query: string;
+  /** The loaded module to start from, as an index; the previous answer's `cursor`. */
+  cursor?: number;
+  /** At most {@link METRO_SEARCH_PAGE_SIZE}, which is also the default. */
+  limit?: number;
+};
+/** The answer to a {@link MetroSearchRequest}. */
+type MetroSearchResult = {
+  type: 'metro-search-result';
+  id: string;
+} & ({
+  ok: true;
+  matches: MetroMatch[];
+  /** Where the next request continues, or `null` once every loaded module is searched. */
+  cursor: number | null;
+  /** How many loaded modules are searched so far, of `total`. */
+  searched: number;
+  total: number;
+} | MetroError);
+/** A loaded module that reported the source file it was built from. */
+type MetroFile = {
+  id: number;
+  /** The path Discord's import tracker reported, such as `modules/user_profile/native/UserProfileStore.tsx`. */
+  path: string;
+};
+/**
+ * Controller → bridge → device: list every loaded module's file path, for a file tree. A module reports its path
+ * only as it loads, so the tree is complete once every module has loaded.
+ */
+type MetroFilesRequest = {
+  type: 'metro-files-request';
+  id: string;
+};
+/** The answer to a {@link MetroFilesRequest}, sorted by path. */
+type MetroFilesResult = {
+  type: 'metro-files-result';
+  id: string;
+} & ({
+  ok: true;
+  files: MetroFile[];
+  /** How many modules have not loaded, whose paths are not known yet. */
+  unloaded: number;
+  count: number;
+} | MetroError);
+/** Controller → bridge → device: describe a value and list a page of its children. */
+type MetroChildrenRequest = {
+  type: 'metro-children-request';
+  id: string;
+  target: MetroTarget;
+  offset?: number;
+  /** At most {@link METRO_CHILDREN_PAGE_SIZE}, which is also the default. */
+  limit?: number;
+};
+/** The answer to a {@link MetroChildrenRequest}. */
+type MetroChildrenResult = {
+  type: 'metro-children-result';
+  id: string;
+} & ({
+  ok: true;
+  /** The target itself. */
+  value: MetroValue;
+  /** A page of its own properties. */
+  children: MetroValue[];
+  /** How many own properties it has. */
+  total: number;
+  /** Its slots, listed after the properties: `[[Entries]]`, `[[Prototype]]`. */
+  internal: MetroValue[];
+} | MetroError);
+/** Controller → bridge → device: run the getter a `getter` value's ref stands for. */
+type MetroReadRequest = {
+  type: 'metro-read-request';
+  id: string;
+  ref: string;
+};
+/** The answer to a {@link MetroReadRequest}: the getter's result, or an `error` value for what it threw. */
+type MetroReadResult = {
+  type: 'metro-read-result';
+  id: string;
+} & ({
+  ok: true;
+  value: MetroValue;
+} | MetroError);
+type MetroRequest = MetroModulesRequest | MetroLoadRequest | MetroLoadAllRequest | MetroSearchRequest | MetroFilesRequest | MetroChildrenRequest | MetroReadRequest;
+type MetroResult = MetroModulesResult | MetroLoadResult | MetroLoadAllResult | MetroSearchResult | MetroFilesResult | MetroChildrenResult | MetroReadResult;
+/** The result frame type answering each request frame type. */
+declare const METRO_RESULT_TYPES: {
+  readonly 'metro-modules-request': 'metro-modules-result';
+  readonly 'metro-load-request': 'metro-load-result';
+  readonly 'metro-load-all-request': 'metro-load-all-result';
+  readonly 'metro-search-request': 'metro-search-result';
+  readonly 'metro-files-request': 'metro-files-result';
+  readonly 'metro-children-request': 'metro-children-result';
+  readonly 'metro-read-request': 'metro-read-result';
+};
+/** A frame narrowed to its type, before its other fields are checked. */
+type TypedFrame = {
+  type: string;
+};
+/**
+ * @description Builds the failed answer to a Metro request.
+ * @param request The request, or its type and id.
+ * @param error What failed.
+ * @param code Why it failed.
+ * @returns The result frame.
+ */
+declare function failMetroRequest(request: Pick<MetroRequest, 'type' | 'id'>, error: string, code: MetroErrorCode): MetroResult;
+/**
+ * @description Checks whether a frame is a Metro request, by its type alone.
+ * @param frame A parsed frame.
+ * @returns Whether it is one.
+ */
+declare function isMetroRequest(frame: TypedFrame): frame is MetroRequest;
+/**
+ * @description Checks whether a frame is a Metro result, by its type alone.
+ * @param frame A parsed frame.
+ * @returns Whether it is one.
+ */
+declare function isMetroResult(frame: TypedFrame): frame is MetroResult;
+/**
+ * The view finder's frames: a controller asks the device for one page of one level of its native view
+ * tree at a time, for one view's properties when it selects it, and names the view to outline on screen.
+ */
+/** The most views a device returns for one {@link ViewsRequest}; a longer level is read in pages. */
+declare const VIEWS_PAGE_SIZE = 100;
+/** A rectangle in screen coordinates, in dp on Android and points on iOS. */
+type ViewFrame = {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+};
+/** One native view, with only its top-level properties. */
+type ViewNode = {
+  /** The device's id for the view, valid until the next request for the roots. */
+  id: string;
+  /** The fully qualified Java class name, or the Objective-C class name. */
+  className: string;
+  /** The Android resource entry name of the view's id, or the iOS accessibility identifier. */
+  resourceName: string | null;
+  frame: ViewFrame;
+  visibility: 'visible' | 'invisible' | 'gone';
+  /** The view's opacity from 0 to 1, or `null` when the platform did not report it. */
+  alpha: number | null;
+  /** The text a text view shows, cut to a few hundred characters. */
+  text: string | null;
+  /** How many direct children the view has. */
+  childCount: number;
+};
+/**
+ * Controller → bridge → device: list a page of the children of `parent`, or the root views when it is
+ * omitted. Listing the roots renews every id.
+ */
+type ViewsRequest = {
+  type: 'views-request';
+  /** Correlation id echoed back on the matching {@link ViewsResult}. */
+  id: string;
+  parent?: string;
+  /** The index of the first child to list. Defaults to 0. */
+  offset?: number;
+  /** How many children to list, at most {@link VIEWS_PAGE_SIZE}, which is also the default. */
+  limit?: number;
+};
+/** The answer to a {@link ViewsRequest}, sent device → bridge → the controller that asked. */
+type ViewsResult = {
+  type: 'views-result';
+  /** The `id` of the {@link ViewsRequest} this answers. */
+  id: string;
+} & ({
+  ok: true;
+  nodes: ViewNode[];
+  /** How many children the parent has in all; more pages follow while it exceeds `offset + nodes.length`. */
+  total?: number;
+} | {
+  ok: false;
+  error: string;
+});
+/** A property value: text, a number, a flag or nothing. A `color` is `#RRGGBBAA`. */
+type ViewPropertyValue = string | number | boolean | null;
+/** One property of a native view, read when the controller selects it. */
+type ViewProperty = {
+  key: string;
+  value: ViewPropertyValue;
+  /** Draws the value as a colour swatch when `color`. */
+  kind?: 'color';
+  /** The unit a number is in, such as `dp`, `pt` or `px`. */
+  unit?: string;
+};
+/** A titled group of properties, such as Layout or Accessibility. */
+type ViewSection = {
+  title: string;
+  properties: ViewProperty[];
+};
+/** What a device reads about one view beyond its {@link ViewNode}, for patching it with the native bridge. */
+type ViewDetails = {
+  /** The view's class, then each superclass up to the platform's root view class. */
+  classChain: string[];
+  sections: ViewSection[];
+};
+/** Controller → bridge → device: read the properties of the listed view `node`. */
+type ViewDetailsRequest = {
+  type: 'view-details-request';
+  /** Correlation id echoed back on the matching {@link ViewDetailsResult}. */
+  id: string;
+  node: string;
+};
+/** The answer to a {@link ViewDetailsRequest}, sent device → bridge → the controller that asked. */
+type ViewDetailsResult = {
+  type: 'view-details-result';
+  /** The `id` of the {@link ViewDetailsRequest} this answers. */
+  id: string;
+} & ({
+  ok: true;
+  details: ViewDetails;
+} | {
+  ok: false;
+  error: string;
+});
+/** Controller → bridge → device: outline the view with this id on screen, or clear the outline when `null`. */
+type ViewHighlight = {
+  type: 'view-highlight';
+  node: string | null;
+};
+/**
+ * React DevTools over the debugger socket: the device's backend and the frontend (the DevTools app's
+ * controller) swap React DevTools' own `{ event, payload }` messages, each wrapped in one frame.
+ */
+/** Device ↔ bridge ↔ the frontend controller: one React DevTools message. */
+type ReactDevtoolsFrame = {
+  type: 'react-devtools';
+  event: string;
+  payload?: unknown;
+};
+/** The payload of {@link REACT_DEVTOOLS_STATUS_EVENT}. */
+type ReactDevtoolsStatus = {
+  connected: boolean;
+  /** Why the backend is unavailable, such as the loader not having run it. */
+  error?: string;
+};
+/**
+ * The event the device sends the frontend, with a {@link ReactDevtoolsStatus}, when its backend
+ * starts a session, cannot start one, or ends one.
+ */
+declare const REACT_DEVTOOLS_STATUS_EVENT = "unbound:backend-status";
+/** React DevTools' own event that ends a backend session; the bridge sends it when the frontend leaves. */
+declare const REACT_DEVTOOLS_SHUTDOWN_EVENT = "shutdown";
+/**
+ * The wire protocol shared by the bridge, the device and controllers: every frame is a JSON-encoded
+ * {@link BridgeMessage}. Dependency-free at runtime so the React Native client can bundle it.
+ */
+/** A request to evaluate code on the device, sent controller → bridge → device. */
+type EvalRequest = {
+  type: 'eval';
+  /** Correlation id echoed back on the matching {@link EvalResult}. */
+  id: string;
+  code: string;
+  timeout?: number;
+};
+/**
+ * Why a request failed before the device answered it, so callers branch on a code instead of the error text.
+ */
+type RequestFailureCode =
+/** The bridge has no device. */
+'no-device' |
+/** The device dropped mid-request. */
+'device-disconnected' | 'timeout' |
+/** The controller has no socket to the bridge. */
+'bridge-unreachable' |
+/** The controller closed. */
+'shut-down';
+/** The outcome of an {@link EvalRequest}, sent device → bridge → the one waiting controller. */
+type EvalResult = {
+  type: 'eval-result';
+  /** The `id` of the {@link EvalRequest} this answers. */
+  id: string;
+  /**
+   * Console output captured during this eval, so callers see its side effects too. Populated by
+   * the controller that owns the request, not sent by the device.
+   */
+  logs?: LogMessage[];
+} & ({
+  ok: true;
+  /** The inspected return value. */
+  value: string;
+} | {
+  ok: false;
+  /** The inspected error. */
+  error: string;
+  /** Set when the bridge or controller failed the eval; absent when the code itself threw on the device. */
+  code?: RequestFailureCode;
+});
+/** The addon managers a push can reload into. */
+type PushedAddonKind = 'plugin' | 'theme';
+/**
+ * A request to hot-reload a plugin or theme on the device, sent controller → bridge → device. Carries
+ * the freshly built bundle and manifest so the device swaps them in without a re-fetch.
+ */
+type PushRequest = {
+  type: 'plugin-push';
+  /** Correlation id echoed back on the matching {@link PushResult}. */
+  id: string;
+  addonId: string;
+  /** Which manager reloads the addon; a plugin when omitted, as pushes from older CLIs are. */
+  kind?: PushedAddonKind;
+  bundle: string;
+  /** The manifest as authored; the device validates it before swapping anything in. */
+  manifest: PushedManifest;
+  /** The bundle compiled to Hermes bytecode, base64-encoded, by bytecode version; its digests are in `manifest.bytecode`. */
+  bytecode?: Record<string, string>;
+  /** Each extra file the manifest lists beside the bundle, such as an image, base64-encoded, by path. */
+  files?: Record<string, string>;
+};
+/** The outcome of a {@link PushRequest}, sent device → bridge → the one waiting controller. */
+type PushResult = {
+  type: 'plugin-push-result';
+  /** The `id` of the {@link PushRequest} this answers. */
+  id: string;
+} & ({
+  ok: true;
+} | {
+  ok: false;
+  /** The reload failure, inspected. */
+  error: string;
+  /** Set when the bridge or controller failed the push; absent when the device's reload failed. */
+  code?: RequestFailureCode;
+});
+/** A `console.*` / `nativeLoggingHook` line, streamed device → bridge → all controllers. */
+type LogMessage = {
+  type: 'log';
+  /** 1 = log/gray, 2 = warn/yellow, 3 = error/red. */
+  level: 1 | 2 | 3;
+  message: string;
+};
+/** What a device reports about itself when it connects. */
+type DeviceInfo = {
+  platform: string;
+  discordVersion: string;
+  loaderVersion: string;
+  clientVersion: string;
+};
+/** Device → bridge, once its socket opens, so the bridge can say which device is attached. */
+type DeviceHello = {
+  type: 'hello';
+  device: DeviceInfo;
+};
+/** Bridge → controller, once on attach and whenever the device connects, drops or says hello. */
+type DeviceStatus = {
+  type: 'device-status';
+} & ({
+  connected: false;
+} | {
+  connected: true;
+  /** Present once the connected device has said hello. */
+  device?: DeviceInfo;
+});
+/**
+ * Bridge → controller, once on attach, from a bridge that advertises itself over Bonjour: the
+ * pairing code its TXT record carries, and how to reach it by hand when discovery fails.
+ */
+type BridgeInfo = {
+  type: 'bridge-info';
+  /** The four-digit pairing code, also the advertisement's `code`. */
+  code: string;
+  /** `ip:port` on the advertised network, for the Debugger Address setting. */
+  address?: string;
+  /** Whether devices on the network can find the bridge. */
+  advertising: boolean;
+  /** Why it isn't advertising. */
+  error?: string;
+};
+/** Every framed message on the wire. */
+type BridgeMessage = EvalRequest | EvalResult | PushRequest | PushResult | LogMessage | DeviceHello | DeviceStatus | BridgeInfo | ViewsRequest | ViewsResult | ViewDetailsRequest | ViewDetailsResult | ViewHighlight | ExplorerRequest | ExplorerResult | MetroRequest | MetroResult | ReactDevtoolsFrame;
+/** The default port the bridge listens on and controllers dial. */
+declare const DEFAULT_BRIDGE_PORT = 9090;
+declare const DEFAULT_EVAL_TIMEOUT_MS = 10000;
+declare const MAX_EVAL_TIMEOUT_MS = 86400000;
+/** How long the bridge waits for the device to reload a pushed addon. */
+declare const PUSH_TIMEOUT_MS = 60000;
+/**
+ * How much longer a controller waits than the bridge, so the bridge's own timeout reply always
+ * arrives before the controller gives up on its own.
+ */
+declare const BRIDGE_REPLY_GRACE_MS = 5000;
+/**
+ * @description Picks how long an eval may run: the requested timeout when it is a positive number of
+ * milliseconds, capped at {@link MAX_EVAL_TIMEOUT_MS}, otherwise {@link DEFAULT_EVAL_TIMEOUT_MS}.
+ * @param requested The timeout the controller asked for, if any.
+ * @returns The timeout to apply, in milliseconds.
+ */
+declare function resolveEvalTimeout(requested: number | undefined): number;
+/** The query marker a controller appends to its URL so the bridge routes it as a controller, not a device. */
+declare const CONTROLLER_ENDPOINT_MARKER = "mcp";
+/** The unlisted `ubd` command that runs the bridge in the foreground; tools that start one run it. */
+declare const SERVE_BRIDGE_COMMAND = "serve-bridge";
+/** The Bonjour service type a bridge advertises, so a device on the same network can find it. */
+declare const BRIDGE_SERVICE_TYPE = "_unbound-bridge._tcp";
+/** The `proto` TXT value of an advertised bridge; a device skips bridges that speak another one. */
+declare const BRIDGE_SERVICE_PROTOCOL = "1";
+/** What an advertised bridge's TXT record holds, beside its instance name, which names the computer. */
+type BridgeAdvertisement = {
+  /** The protocol version, {@link BRIDGE_SERVICE_PROTOCOL}. */
+  proto: string;
+  /** The tool that started the bridge. */
+  by: 'devtools' | 'cli';
+  /** The four-digit pairing code the tool also shows, so the user can tell it is their computer. */
+  code: string;
+};
+/**
+ * @description Safely parses a raw wire frame into a {@link BridgeMessage}, guarding against invalid
+ * JSON and unknown shapes so both ends can trust what they route.
+ * @param raw The JSON string received off the socket.
+ * @returns The parsed message, or `undefined` if it isn't a recognised frame.
+ */
+declare function parseMessage(raw: string): BridgeMessage | undefined;
+/**
+ * @description Serialises a {@link BridgeMessage} into its wire form. Inverse of {@link parseMessage}.
+ * @param message The message to frame.
+ * @returns The JSON string to send over the socket.
+ */
+declare function serializeMessage(message: BridgeMessage): string;
+declare const _default: {
+  DEFAULT_BRIDGE_PORT: number;
+  DEFAULT_EVAL_TIMEOUT_MS: number;
+  MAX_EVAL_TIMEOUT_MS: number;
+  PUSH_TIMEOUT_MS: number;
+  BRIDGE_REPLY_GRACE_MS: number;
+  CONTROLLER_ENDPOINT_MARKER: string;
+  REACT_DEVTOOLS_SHUTDOWN_EVENT: string;
+  REACT_DEVTOOLS_STATUS_EVENT: string;
+  resolveEvalTimeout: typeof resolveEvalTimeout;
+  parseMessage: typeof parseMessage;
+  serializeMessage: typeof serializeMessage;
+};
+export { MetroFilesResult as $, ReactDevtoolsStatus as A, ExplorerImage as At, ViewSection as B, ExplorerTarget as Bt, _default as C, EXPLORER_RESULT_TYPES as Ct, REACT_DEVTOOLS_SHUTDOWN_EVENT as D, ExplorerClassesResult as Dt, serializeMessage as E, ExplorerClassesRequest as Et, ViewFrame as F, ExplorerObject as Ft, METRO_RESULT_TYPES as G, failExplorerRequest as Gt, ViewsResult as H, ExplorerValueKind as Ht, ViewHighlight as I, ExplorerObjectRequest as It, MetroChildrenResult as J, METRO_SEARCH_PAGE_SIZE as K, isExplorerRequest as Kt, ViewNode as L, ExplorerObjectResult as Lt, ViewDetails as M, ExplorerMemberKind as Mt, ViewDetailsRequest as N, ExplorerMembersRequest as Nt, REACT_DEVTOOLS_STATUS_EVENT as O, ExplorerError as Ot, ViewDetailsResult as P, ExplorerMembersResult as Pt, MetroFilesRequest as Q, ViewProperty as R, ExplorerRequest as Rt, SERVE_BRIDGE_COMMAND as S, EXPLORER_MEMBERS_PAGE_SIZE as St, resolveEvalTimeout as T, ExplorerClass as Tt, METRO_CHILDREN_PAGE_SIZE as U, ExplorerValuesRequest as Ut, ViewsRequest as V, ExplorerValue as Vt, METRO_MODULES_PAGE_SIZE as W, ExplorerValuesResult as Wt, MetroErrorCode as X, MetroError as Y, MetroFile as Z, PUSH_TIMEOUT_MS as _, MetroValueKind as _t, BridgeInfo as a, MetroModule as at, PushedAddonKind as b, isMetroResult as bt, DEFAULT_BRIDGE_PORT as c, MetroModulesResult as ct, DeviceInfo as d, MetroRequest as dt, MetroLoadAllRequest as et, DeviceStatus as f, MetroResult as ft, MAX_EVAL_TIMEOUT_MS as g, MetroValue as gt, LogMessage as h, MetroTarget as ht, BridgeAdvertisement as i, MetroMatch as it, VIEWS_PAGE_SIZE as j, ExplorerMember as jt, ReactDevtoolsFrame as k, ExplorerErrorCode as kt, DEFAULT_EVAL_TIMEOUT_MS as l, MetroReadRequest as lt, EvalResult as m, MetroSearchResult as mt, BRIDGE_SERVICE_PROTOCOL as n, MetroLoadRequest as nt, BridgeMessage as o, MetroModuleStatus as ot, EvalRequest as p, MetroSearchRequest as pt, MetroChildrenRequest as q, isExplorerResult as qt, BRIDGE_SERVICE_TYPE as r, MetroLoadResult as rt, CONTROLLER_ENDPOINT_MARKER as s, MetroModulesRequest as st, BRIDGE_REPLY_GRACE_MS as t, MetroLoadAllResult as tt, DeviceHello as u, MetroReadResult as ut, PushRequest as v, failMetroRequest as vt, parseMessage as w, EXPLORER_VALUES_LIMIT as wt, RequestFailureCode as x, EXPLORER_CLASSES_PAGE_SIZE as xt, PushResult as y, isMetroRequest as yt, ViewPropertyValue as z, ExplorerResult as zt };