@ai-matrx/desktop-protocol 0.21.38 → 0.21.39

package/dist/client.js

@@ -112,7 +112,7 @@ import { z as z2 } from "zod";
 import { z } from "zod";
 import { UUID_SHAPE_PATTERN } from "@ai-matrx/kit/uuid";
 var PROTOCOL_MAJOR = 1;
-var PROTOCOL_MINOR = 46;
+var PROTOCOL_MINOR = 47;
 var PROTOCOL_VERSION = `${PROTOCOL_MAJOR}.${PROTOCOL_MINOR}`;
 var ProtocolVersion = z.string().regex(/^[1-9][0-9]{0,2}\.[0-9]{1,3}$/);
 var RequestId = z.string().min(1).max(64).regex(/^[A-Za-z0-9_-]+$/);
@@ -3341,22 +3341,104 @@ var AppsWindowsUpdateAndReopenResult = z31.strictObject({
   installed_version: z31.string().max(64).nullable()
 });
 
-// src/schema/browser.ts
+// src/schema/apps-instances.ts
 import { z as z32 } from "zod";
-var BrowserClientInstance = z32.string().min(1).max(64).regex(/^[A-Za-z0-9_.:-]+$/);
-var BrowserKind = z32.enum(["chrome", "edge", "brave", "arc", "opera", "vivaldi", "chromium", "firefox", "other"]);
-var BrowserSessionState = z32.enum(["connected", "different_account", "extension_signed_out", "device_signed_out", "unverified"]);
-var BrowserSession = z32.strictObject({
+var InstanceStatus = z32.enum(["open", "closed", "wrong_account", "update_waiting", "folder_missing"]);
+var AppInstall = z32.strictObject({
+  location: z32.string().max(1024),
+  version: z32.string().max(80).nullable()
+});
+var AppInstance = z32.strictObject({
+  app_key: AppKey,
+  /** "main", or the instance's name: the same key every window action takes. */
+  key: ChatPlace,
+  main: z32.boolean(),
+  status: InstanceStatus,
+  running: z32.boolean(),
+  /** Its process while open. */
+  pid: nonNegInt.nullable(),
+  /** Its data folder on this device. */
+  folder: z32.string().max(1024).nullable(),
+  folder_exists: z32.boolean(),
+  /** The provider's id of the account signed in there now, when the app records it. */
+  account_id: z32.string().max(200).nullable(),
+  /** That account's email, when known. */
+  account: z32.string().max(320).nullable(),
+  /** The account this instance is kept for (null for main: it signs into any). */
+  meant_for: z32.string().max(320).nullable(),
+  /** The version running in it now, or the one it last ran when closed. */
+  version: z32.string().max(80).nullable(),
+  installed_version: z32.string().max(80).nullable(),
+  /** Chats open in it now. */
+  open_chats: nonNegInt,
+  launched_ms: epochMs.nullable(),
+  quit_ms: epochMs.nullable(),
+  first_launch_ms: epochMs.nullable()
+});
+var AccountResetSource = z32.enum(["app", "usage_history", "your_list"]);
+var AccountGap = z32.enum(["email", "plan", "usage"]);
+var AppAccount = z32.strictObject({
+  app_key: AppKey,
+  /** The provider's own account id (Claude's account uuid, ChatGPT's account id); `org:<uuid>` when only its organization is known. */
+  account_id: z32.string().max(200),
+  email: z32.string().max(320).nullable(),
+  plan: z32.string().max(80).nullable(),
+  /** The provider organizations its readings are filed under. */
+  orgs: z32.array(z32.string().max(80)).max(20),
+  /** Weekly use in percent; 0 once the week reset after the reading. */
+  weekly: z32.number().nullable(),
+  weekly_reset_since: z32.boolean(),
+  weekly_resets_at_ms: epochMs.nullable(),
+  weekly_reset_source: AccountResetSource.nullable(),
+  /** 5-hour use in percent; 0 once the 5-hour window passed after the reading. */
+  five_hour: z32.number().nullable(),
+  five_hour_reset_since: z32.boolean(),
+  /** The latest the 5-hour window resets. */
+  five_hour_resets_at_ms: epochMs.nullable(),
+  /** Claude: extra-usage spend as a percent of its cap. */
+  extra_usage: z32.number().nullable(),
+  /** Codex: the credit balance. */
+  credits: z32.number().nullable(),
+  /** When the newest reading was taken, and in which instance. */
+  read_at_ms: epochMs.nullable(),
+  read_in: ChatPlace.nullable(),
+  /** Instances signed into it now. */
+  instances: z32.array(ChatPlace).max(200),
+  first_seen_ms: epochMs.nullable(),
+  last_seen_ms: epochMs.nullable(),
+  missing: z32.array(AccountGap).max(3)
+});
+var AppsInstancesListParams = z32.strictObject({ app_key: AppKey });
+var AppsInstancesListResult = z32.strictObject({
+  app_key: AppKey,
+  install: AppInstall.nullable(),
+  instances: z32.array(AppInstance).max(200),
+  /** The rows are right but something around them failed; shown, never hidden. */
+  problem: z32.string().max(400).optional()
+});
+var AppsAccountsListParams = z32.strictObject({ app_key: AppKey });
+var AppsAccountsListResult = z32.strictObject({
+  app_key: AppKey,
+  accounts: z32.array(AppAccount).max(500),
+  problem: z32.string().max(400).optional()
+});
+
+// src/schema/browser.ts
+import { z as z33 } from "zod";
+var BrowserClientInstance = z33.string().min(1).max(64).regex(/^[A-Za-z0-9_.:-]+$/);
+var BrowserKind = z33.enum(["chrome", "edge", "brave", "arc", "opera", "vivaldi", "chromium", "firefox", "other"]);
+var BrowserSessionState = z33.enum(["connected", "different_account", "extension_signed_out", "device_signed_out", "unverified"]);
+var BrowserSession = z33.strictObject({
   client_instance: BrowserClientInstance,
   /** What the person sees ("Chrome — Work"), set by the extension. */
-  client_label: z32.string().min(1).max(128),
+  client_label: z33.string().min(1).max(128),
   browser: BrowserKind,
-  extension_version: z32.string().min(1).max(32),
+  extension_version: z33.string().min(1).max(32),
   state: BrowserSessionState,
   /** True only for `connected`: an agent's call can reach this session. */
-  routable: z32.boolean(),
+  routable: z33.boolean(),
   /** The extension's account email from its token (null when signed out or unknown). */
-  account_email: z32.string().max(320).nullable(),
+  account_email: z33.string().max(320).nullable(),
   connected_at_ms: epochMs,
   last_call_at_ms: epochMs.nullable(),
   calls: nonNegInt,
@@ -3365,756 +3447,756 @@ var BrowserSession = z32.strictObject({
   p50_ms: nonNegInt.nullable(),
   p95_ms: nonNegInt.nullable(),
   /** A call is waiting for the person to confirm it in the browser. */
-  awaiting_confirmation: z32.boolean()
+  awaiting_confirmation: z33.boolean()
 });
-var BrowserRegisterParams = z32.strictObject({
+var BrowserRegisterParams = z33.strictObject({
   client_instance: BrowserClientInstance,
-  client_label: z32.string().min(1).max(128),
+  client_label: z33.string().min(1).max(128),
   browser: BrowserKind,
-  extension_version: z32.string().min(1).max(32),
+  extension_version: z33.string().min(1).max(32),
   /** The extension's current AI Matrx access token, checked against the device owner; null when signed out. */
-  account_token: z32.string().min(16).max(8192).nullable()
+  account_token: z33.string().min(16).max(8192).nullable()
 });
-var BrowserRegisterResult = z32.strictObject({ session: BrowserSession });
-var BrowserCallError = z32.strictObject({
-  message: z32.string().max(1e3),
+var BrowserRegisterResult = z33.strictObject({ session: BrowserSession });
+var BrowserCallError = z33.strictObject({
+  message: z33.string().max(1e3),
   /** The extension's own error code, when it has one ("tool_not_found", "denied"). */
-  code: z32.string().max(64).nullable()
+  code: z33.string().max(64).nullable()
 });
-var BrowserResultParams = z32.strictObject({
-  call_id: z32.string().min(1).max(64),
-  ok: z32.boolean(),
+var BrowserResultParams = z33.strictObject({
+  call_id: z33.string().min(1).max(64),
+  ok: z33.boolean(),
   /** The tool's result when ok (any JSON). */
-  result: z32.unknown(),
+  result: z33.unknown(),
   error: BrowserCallError.nullable()
 });
-var BrowserResultResult = z32.strictObject({ accepted: z32.boolean() });
-var BrowserCallPhase = z32.enum(["awaiting_confirmation", "running"]);
-var BrowserProgressParams = z32.strictObject({ call_id: z32.string().min(1).max(64), phase: BrowserCallPhase });
-var BrowserProgressResult = z32.strictObject({ accepted: z32.boolean() });
-var BrowserSessionsParams = z32.strictObject({});
-var BrowserSessionsResult = z32.strictObject({
+var BrowserResultResult = z33.strictObject({ accepted: z33.boolean() });
+var BrowserCallPhase = z33.enum(["awaiting_confirmation", "running"]);
+var BrowserProgressParams = z33.strictObject({ call_id: z33.string().min(1).max(64), phase: BrowserCallPhase });
+var BrowserProgressResult = z33.strictObject({ accepted: z33.boolean() });
+var BrowserSessionsParams = z33.strictObject({});
+var BrowserSessionsResult = z33.strictObject({
   /** The person's Browser connection switch. Off: no pairing, no extension sessions. */
-  enabled: z32.boolean(),
+  enabled: z33.boolean(),
   /** Whether Matrx 2 is signed in (without an owner no session is routable). */
-  owner_signed_in: z32.boolean(),
-  sessions: z32.array(BrowserSession).max(64)
-});
-var BrowserDisconnectParams = z32.strictObject({ client_instance: BrowserClientInstance });
-var BrowserDisconnectResult = z32.strictObject({ disconnected: z32.boolean() });
-var BrowserSetEnabledParams = z32.strictObject({ enabled: z32.boolean() });
-var BrowserSetEnabledResult = z32.strictObject({ enabled: z32.boolean() });
-var BrowserPairCodeParams = z32.strictObject({});
-var BrowserPairCodeResult = z32.strictObject({ code: z32.string().min(16).max(128) });
-var BrowserPairResetParams = z32.strictObject({});
-var BrowserCallParams = z32.strictObject({
-  tool: z32.string().min(1).max(96).regex(/^[a-z][a-z0-9_]*$/),
-  args: z32.record(z32.string(), z32.unknown()),
+  owner_signed_in: z33.boolean(),
+  sessions: z33.array(BrowserSession).max(64)
+});
+var BrowserDisconnectParams = z33.strictObject({ client_instance: BrowserClientInstance });
+var BrowserDisconnectResult = z33.strictObject({ disconnected: z33.boolean() });
+var BrowserSetEnabledParams = z33.strictObject({ enabled: z33.boolean() });
+var BrowserSetEnabledResult = z33.strictObject({ enabled: z33.boolean() });
+var BrowserPairCodeParams = z33.strictObject({});
+var BrowserPairCodeResult = z33.strictObject({ code: z33.string().min(16).max(128) });
+var BrowserPairResetParams = z33.strictObject({});
+var BrowserCallParams = z33.strictObject({
+  tool: z33.string().min(1).max(96).regex(/^[a-z][a-z0-9_]*$/),
+  args: z33.record(z33.string(), z33.unknown()),
   /** Which session; default: the most recently active routable one (BROWSER ambiguity → CONFLICT). */
   client_instance: BrowserClientInstance.optional(),
   /** How long to wait, including a person's confirmation; default 120 s. */
-  timeout_ms: z32.int().min(1e3).max(6e5).optional()
+  timeout_ms: z33.int().min(1e3).max(6e5).optional()
 });
-var BrowserCallResult = z32.strictObject({
+var BrowserCallResult = z33.strictObject({
   client_instance: BrowserClientInstance,
-  result: z32.unknown(),
+  result: z33.unknown(),
   duration_ms: nonNegInt
 });
-var BrowserToolMetricsParams = z32.strictObject({ client_instance: BrowserClientInstance });
-var BrowserToolMetric = z32.strictObject({
-  tool: z32.string().max(256),
+var BrowserToolMetricsParams = z33.strictObject({ client_instance: BrowserClientInstance });
+var BrowserToolMetric = z33.strictObject({
+  tool: z33.string().max(256),
   calls: nonNegInt,
   errors: nonNegInt,
   /** Over the last 200 answered calls; null before the first answer. */
   p50_ms: nonNegInt.nullable(),
   p95_ms: nonNegInt.nullable(),
   last_call_at_ms: epochMs.nullable(),
-  last_error: z32.string().max(2048).nullable()
+  last_error: z33.string().max(2048).nullable()
 });
-var BrowserToolMetricsResult = z32.strictObject({ client_instance: z32.string(), tools: z32.array(BrowserToolMetric) });
-var BrowserResetCountersParams = z32.strictObject({ client_instance: BrowserClientInstance });
-var BrowserResetCountersResult = z32.strictObject({ reset: z32.boolean() });
-var BrowserLogParams = z32.strictObject({
+var BrowserToolMetricsResult = z33.strictObject({ client_instance: z33.string(), tools: z33.array(BrowserToolMetric) });
+var BrowserResetCountersParams = z33.strictObject({ client_instance: BrowserClientInstance });
+var BrowserResetCountersResult = z33.strictObject({ reset: z33.boolean() });
+var BrowserLogParams = z33.strictObject({
   /** Only messages after this seq (0: from the oldest kept; the core keeps the last 500). */
   after_seq: nonNegInt.default(0),
-  limit: z32.int().min(1).max(500).default(500)
+  limit: z33.int().min(1).max(500).default(500)
 });
-var BrowserLogMessage = z32.strictObject({
+var BrowserLogMessage = z33.strictObject({
   seq: nonNegInt,
   at_ms: epochMs,
-  direction: z32.enum(["to_browser", "from_browser", "core"]),
-  client_instance: z32.string(),
-  kind: z32.enum(["register", "invoke", "result", "progress", "timeout", "closed"]),
-  tool: z32.string().nullable(),
-  call_id: z32.string().nullable(),
-  ok: z32.boolean().nullable(),
-  detail: z32.string().max(1024)
-});
-var BrowserLogResult = z32.strictObject({
-  messages: z32.array(BrowserLogMessage),
+  direction: z33.enum(["to_browser", "from_browser", "core"]),
+  client_instance: z33.string(),
+  kind: z33.enum(["register", "invoke", "result", "progress", "timeout", "closed"]),
+  tool: z33.string().nullable(),
+  call_id: z33.string().nullable(),
+  ok: z33.boolean().nullable(),
+  detail: z33.string().max(1024)
+});
+var BrowserLogResult = z33.strictObject({
+  messages: z33.array(BrowserLogMessage),
   /** The newest seq the core has written (pass it back as after_seq to follow the log). */
   last_seq: nonNegInt
 });
-var BrowserInvokeEvent = z32.strictObject({
-  call_id: z32.string().min(1).max(64),
-  tool: z32.string().min(1).max(96),
-  args: z32.record(z32.string(), z32.unknown()),
+var BrowserInvokeEvent = z33.strictObject({
+  call_id: z33.string().min(1).max(64),
+  tool: z33.string().min(1).max(96),
+  args: z33.record(z33.string(), z33.unknown()),
   deadline_ms: epochMs
 });
-var BrowserSessionsChangedEvent = z32.strictObject({ count: nonNegInt, enabled: z32.boolean() });
-var BrowserProgressEvent = z32.strictObject({
-  call_id: z32.string().min(1).max(64),
+var BrowserSessionsChangedEvent = z33.strictObject({ count: nonNegInt, enabled: z33.boolean() });
+var BrowserProgressEvent = z33.strictObject({
+  call_id: z33.string().min(1).max(64),
   client_instance: BrowserClientInstance,
   phase: BrowserCallPhase
 });
-var DesktopHealth = z32.strictObject({
-  status: z32.literal("ok"),
-  service: z32.literal("matrx-desktop"),
-  version: z32.string().max(32),
-  protocol_version: z32.string().max(16),
-  ws_path: z32.literal("/v1/connect"),
-  device_id: z32.string().max(64),
-  browser_connection: z32.enum(["on", "off"])
-});
-var BrowserPairRequest = z32.strictObject({ client_instance: BrowserClientInstance });
-var BrowserPairResult = z32.strictObject({ pair_token: z32.string().min(16).max(128), ws_path: z32.literal("/v1/connect") });
+var DesktopHealth = z33.strictObject({
+  status: z33.literal("ok"),
+  service: z33.literal("matrx-desktop"),
+  version: z33.string().max(32),
+  protocol_version: z33.string().max(16),
+  ws_path: z33.literal("/v1/connect"),
+  device_id: z33.string().max(64),
+  browser_connection: z33.enum(["on", "off"])
+});
+var BrowserPairRequest = z33.strictObject({ client_instance: BrowserClientInstance });
+var BrowserPairResult = z33.strictObject({ pair_token: z33.string().min(16).max(128), ws_path: z33.literal("/v1/connect") });
 
 // src/schema/net.ts
-import { z as z33 } from "zod";
-var NetInfoParams = z33.strictObject({});
-var NetAddress = z33.strictObject({
-  address: z33.string(),
-  family: z33.enum(["ipv4", "ipv6"]),
-  netmask: z33.string().nullable(),
+import { z as z34 } from "zod";
+var NetInfoParams = z34.strictObject({});
+var NetAddress = z34.strictObject({
+  address: z34.string(),
+  family: z34.enum(["ipv4", "ipv6"]),
+  netmask: z34.string().nullable(),
   /** CIDR form ("192.168.1.20/24"); null where the OS gives no prefix. */
-  cidr: z33.string().nullable()
+  cidr: z34.string().nullable()
 });
-var NetInterface = z33.strictObject({
-  name: z33.string(),
-  mac: z33.string().nullable(),
+var NetInterface = z34.strictObject({
+  name: z34.string(),
+  mac: z34.string().nullable(),
   /** Loopback and other internal interfaces. */
-  internal: z33.boolean(),
-  addresses: z33.array(NetAddress)
+  internal: z34.boolean(),
+  addresses: z34.array(NetAddress)
 });
-var NetInfoResult = z33.strictObject({
-  hostname: z33.string(),
-  interfaces: z33.array(NetInterface),
+var NetInfoResult = z34.strictObject({
+  hostname: z34.string(),
+  interfaces: z34.array(NetInterface),
   /** The default route's gateway; null when the OS does not say (or there is none). */
-  gateway: z33.string().nullable(),
+  gateway: z34.string().nullable(),
   /** The DNS servers the OS uses; empty when it does not say. */
-  dns: z33.array(z33.string())
+  dns: z34.array(z34.string())
 });
-var NetWifiParams = z33.strictObject({});
-var NetWifiNetwork = z33.strictObject({
+var NetWifiParams = z34.strictObject({});
+var NetWifiNetwork = z34.strictObject({
   /** null: the OS hides the name (macOS without Location Services for this app). */
-  ssid: z33.string().nullable(),
+  ssid: z34.string().nullable(),
   /** dBm; null where the OS does not say. */
-  rssi: z33.int().nullable(),
-  channel: z33.string().nullable(),
-  security: z33.string().nullable()
+  rssi: z34.int().nullable(),
+  channel: z34.string().nullable(),
+  security: z34.string().nullable()
 });
-var NetWifiResult = z33.strictObject({
+var NetWifiResult = z34.strictObject({
   /** Whether the computer has a Wi-Fi interface at all. */
-  available: z33.boolean(),
+  available: z34.boolean(),
   /** The network the computer is on; null when it is on none. */
   current: NetWifiNetwork.nullable(),
   /** Networks in range (may be empty where the OS lists none to apps). */
-  networks: z33.array(NetWifiNetwork)
+  networks: z34.array(NetWifiNetwork)
 });
-var NetBluetoothParams = z33.strictObject({});
-var NetBluetoothDevice = z33.strictObject({
-  name: z33.string(),
-  address: z33.string().nullable(),
-  connected: z33.boolean(),
+var NetBluetoothParams = z34.strictObject({});
+var NetBluetoothDevice = z34.strictObject({
+  name: z34.string(),
+  address: z34.string().nullable(),
+  connected: z34.boolean(),
   /** What it is, in the OS's words ("Headphones", "Keyboard"); null where it does not say. */
-  kind: z33.string().nullable(),
+  kind: z34.string().nullable(),
   /** Battery percent, where the OS reports it. */
-  battery: z33.int().min(0).max(100).nullable()
+  battery: z34.int().min(0).max(100).nullable()
 });
-var NetBluetoothResult = z33.strictObject({
+var NetBluetoothResult = z34.strictObject({
   /** Bluetooth is on; null where the OS does not say. */
-  powered: z33.boolean().nullable(),
-  devices: z33.array(NetBluetoothDevice)
-});
-var NetDevicesParams = z33.strictObject({});
-var NetDevice = z33.strictObject({
-  ip: z33.string(),
-  mac: z33.string().nullable(),
-  interface: z33.string().nullable(),
+  powered: z34.boolean().nullable(),
+  devices: z34.array(NetBluetoothDevice)
+});
+var NetDevicesParams = z34.strictObject({});
+var NetDevice = z34.strictObject({
+  ip: z34.string(),
+  mac: z34.string().nullable(),
+  interface: z34.string().nullable(),
   /** The name the local network gives it (reverse DNS / mDNS), when the table carries one. */
-  hostname: z33.string().nullable()
+  hostname: z34.string().nullable()
 });
-var NetDevicesResult = z33.strictObject({ devices: z33.array(NetDevice) });
-var NetMdnsParams = z33.strictObject({
+var NetDevicesResult = z34.strictObject({ devices: z34.array(NetDevice) });
+var NetMdnsParams = z34.strictObject({
   /** A service type ("_http._tcp"); absent lists the service types found. */
-  service_type: z33.string().min(1).max(64).regex(/^_[A-Za-z0-9-]+\._(tcp|udp)$/).optional(),
+  service_type: z34.string().min(1).max(64).regex(/^_[A-Za-z0-9-]+\._(tcp|udp)$/).optional(),
   /** How long to listen. */
-  timeout_s: z33.int().min(1).max(30).default(3)
+  timeout_s: z34.int().min(1).max(30).default(3)
 });
-var NetMdnsService = z33.strictObject({
-  name: z33.string(),
-  type: z33.string(),
-  domain: z33.string(),
-  interface: z33.string().nullable()
+var NetMdnsService = z34.strictObject({
+  name: z34.string(),
+  type: z34.string(),
+  domain: z34.string(),
+  interface: z34.string().nullable()
 });
-var NetMdnsResult = z33.strictObject({ services: z33.array(NetMdnsService) });
-var NetScanParams = z33.strictObject({
+var NetMdnsResult = z34.strictObject({ services: z34.array(NetMdnsService) });
+var NetScanParams = z34.strictObject({
   /** A host name or address; a private or loopback address unless `allow_public`. */
-  host: z33.string().min(1).max(253),
-  ports: z33.array(z33.int().min(1).max(65535)).min(1).max(1024),
-  timeout_ms: z33.int().min(50).max(1e4).default(800),
+  host: z34.string().min(1).max(253),
+  ports: z34.array(z34.int().min(1).max(65535)).min(1).max(1024),
+  timeout_ms: z34.int().min(50).max(1e4).default(800),
   /** Scanning a host on the public internet needs saying so. */
-  allow_public: z33.boolean().default(false)
+  allow_public: z34.boolean().default(false)
 });
-var NetScanResult = z33.strictObject({
-  host: z33.string(),
+var NetScanResult = z34.strictObject({
+  host: z34.string(),
   /** The address the host resolved to. */
-  address: z33.string(),
-  open: z33.array(z33.int().min(1).max(65535)),
+  address: z34.string(),
+  open: z34.array(z34.int().min(1).max(65535)),
   closed: nonNegInt,
   elapsed_ms: nonNegInt
 });
-var NetDownloadParams = z33.strictObject({
-  url: z33.string().min(1).max(8192).regex(/^https?:\/\//),
+var NetDownloadParams = z34.strictObject({
+  url: z34.string().min(1).max(8192).regex(/^https?:\/\//),
   /** Where to save it: an absolute path (a folder keeps the URL's file name). */
   path: AbsPath,
-  overwrite: z33.boolean().default(false),
-  timeout_s: z33.int().min(1).max(3600).default(300),
+  overwrite: z34.boolean().default(false),
+  timeout_s: z34.int().min(1).max(3600).default(300),
   /** Refuse anything larger. */
-  max_bytes: z33.int().min(1).max(10737418240).default(2147483648)
+  max_bytes: z34.int().min(1).max(10737418240).default(2147483648)
 });
-var NetDownloadResult = z33.strictObject({
-  path: z33.string(),
+var NetDownloadResult = z34.strictObject({
+  path: z34.string(),
   bytes: nonNegInt,
-  content_type: z33.string().nullable(),
+  content_type: z34.string().nullable(),
   /** The final URL after redirects. */
-  url: z33.string(),
+  url: z34.string(),
   elapsed_ms: nonNegInt
 });
 
 // src/schema/personal.ts
-import { z as z34 } from "zod";
-var Text = z34.string().max(65536);
-var AutomationScriptParams = z34.strictObject({
+import { z as z35 } from "zod";
+var Text = z35.string().max(65536);
+var AutomationScriptParams = z35.strictObject({
   /** applescript and jxa: macOS (osascript); powershell: Windows (and pwsh where installed). */
-  language: z34.enum(["applescript", "jxa", "powershell"]),
-  script: z34.string().min(1).max(262144),
-  timeout_s: z34.int().min(1).max(600).default(60)
-});
-var AutomationScriptResult = z34.strictObject({
-  stdout: z34.string(),
-  stderr: z34.string(),
-  exit_code: z34.int(),
-  timed_out: z34.boolean(),
+  language: z35.enum(["applescript", "jxa", "powershell"]),
+  script: z35.string().min(1).max(262144),
+  timeout_s: z35.int().min(1).max(600).default(60)
+});
+var AutomationScriptResult = z35.strictObject({
+  stdout: z35.string(),
+  stderr: z35.string(),
+  exit_code: z35.int(),
+  timed_out: z35.boolean(),
   /** stdout or stderr was cut at 1 MiB. */
-  truncated: z34.boolean(),
+  truncated: z35.boolean(),
   elapsed_ms: nonNegInt
 });
-var MailAccountsParams = z34.strictObject({});
-var MailAccount = z34.strictObject({ name: z34.string(), emails: z34.array(z34.string()), enabled: z34.boolean() });
-var MailAccountsResult = z34.strictObject({ accounts: z34.array(MailAccount) });
-var MailListParams = z34.strictObject({
+var MailAccountsParams = z35.strictObject({});
+var MailAccount = z35.strictObject({ name: z35.string(), emails: z35.array(z35.string()), enabled: z35.boolean() });
+var MailAccountsResult = z35.strictObject({ accounts: z35.array(MailAccount) });
+var MailListParams = z35.strictObject({
   /** The account's name in Mail; absent: every account. */
-  account: z34.string().min(1).max(256).optional(),
+  account: z35.string().min(1).max(256).optional(),
   /** The mailbox's name ("INBOX", "Sent Messages"). */
-  mailbox: z34.string().min(1).max(256).default("INBOX"),
-  unread_only: z34.boolean().default(false),
-  limit: z34.int().min(1).max(200).default(25)
-});
-var MailMessage = z34.strictObject({
-  id: z34.string(),
-  subject: z34.string(),
-  sender: z34.string(),
+  mailbox: z35.string().min(1).max(256).default("INBOX"),
+  unread_only: z35.boolean().default(false),
+  limit: z35.int().min(1).max(200).default(25)
+});
+var MailMessage = z35.strictObject({
+  id: z35.string(),
+  subject: z35.string(),
+  sender: z35.string(),
   received_at_ms: epochMs.nullable(),
-  read: z34.boolean(),
-  account: z34.string(),
-  mailbox: z34.string(),
+  read: z35.boolean(),
+  account: z35.string(),
+  mailbox: z35.string(),
   /** The first lines of the message's text. */
-  preview: z34.string()
+  preview: z35.string()
 });
-var MailListResult = z34.strictObject({ messages: z34.array(MailMessage) });
-var MailSendParams = z34.strictObject({
-  to: z34.array(z34.string().min(3).max(320)).min(1).max(50),
-  cc: z34.array(z34.string().min(3).max(320)).max(50).default([]),
-  subject: z34.string().max(998),
+var MailListResult = z35.strictObject({ messages: z35.array(MailMessage) });
+var MailSendParams = z35.strictObject({
+  to: z35.array(z35.string().min(3).max(320)).min(1).max(50),
+  cc: z35.array(z35.string().min(3).max(320)).max(50).default([]),
+  subject: z35.string().max(998),
   body: Text,
   /** The sending account's address; absent: Mail's default. */
-  from: z34.string().min(3).max(320).optional(),
+  from: z35.string().min(3).max(320).optional(),
   /** false leaves it open in Mail as a draft for the person to send. */
-  send: z34.boolean().default(true)
+  send: z35.boolean().default(true)
 });
-var MailSendResult = z34.strictObject({ sent: z34.boolean() });
-var OutlookStatusParams = z34.strictObject({});
-var OutlookAccount = z34.strictObject({ name: z34.string(), email: z34.string().nullable() });
-var OutlookStatusResult = z34.strictObject({
+var MailSendResult = z35.strictObject({ sent: z35.boolean() });
+var OutlookStatusParams = z35.strictObject({});
+var OutlookAccount = z35.strictObject({ name: z35.string(), email: z35.string().nullable() });
+var OutlookStatusResult = z35.strictObject({
   /** classic_windows: scriptable. new_windows / mac: installed, not scriptable. none: not found. */
-  client: z34.enum(["classic_windows", "new_windows", "mac", "none"]),
-  scriptable: z34.boolean(),
-  version: z34.string().nullable(),
-  accounts: z34.array(OutlookAccount),
+  client: z35.enum(["classic_windows", "new_windows", "mac", "none"]),
+  scriptable: z35.boolean(),
+  version: z35.string().nullable(),
+  accounts: z35.array(OutlookAccount),
   /** Why it is not scriptable here, in a sentence the person can act on; null when it is. */
-  reason: z34.string().nullable()
-});
-var Address = z34.string().min(3).max(320);
-var OutlookDraftParams = z34.strictObject({
-  to: z34.array(Address).max(100).default([]),
-  cc: z34.array(Address).max(100).default([]),
-  bcc: z34.array(Address).max(100).default([]),
-  subject: z34.string().max(998).default(""),
-  body: z34.string().max(1048576).default(""),
-  body_format: z34.enum(["text", "html"]).default("text"),
+  reason: z35.string().nullable()
+});
+var Address = z35.string().min(3).max(320);
+var OutlookDraftParams = z35.strictObject({
+  to: z35.array(Address).max(100).default([]),
+  cc: z35.array(Address).max(100).default([]),
+  bcc: z35.array(Address).max(100).default([]),
+  subject: z35.string().max(998).default(""),
+  body: z35.string().max(1048576).default(""),
+  body_format: z35.enum(["text", "html"]).default("text"),
   /** Files on this computer to attach (absolute paths). */
-  attachments: z34.array(z34.string().min(1).max(4096)).max(50).default([]),
+  attachments: z35.array(z35.string().min(1).max(4096)).max(50).default([]),
   /** The sending account's address (one of outlook.status's accounts); absent: Outlook's default. */
   account: Address.optional(),
   /** true also opens the draft in a window for the person. */
-  display: z34.boolean().default(false)
+  display: z35.boolean().default(false)
 });
-var OutlookDraftResult = z34.strictObject({
+var OutlookDraftResult = z35.strictObject({
   /** The draft's id in Outlook (outlook.read takes it). */
-  id: z34.string(),
-  account: z34.string().nullable(),
-  folder: z34.string(),
+  id: z35.string(),
+  account: z35.string().nullable(),
+  folder: z35.string(),
   attachments: nonNegInt,
-  displayed: z34.boolean()
+  displayed: z35.boolean()
 });
-var OutlookListParams = z34.strictObject({
-  folder: z34.enum(["inbox", "sent", "drafts"]).default("inbox"),
+var OutlookListParams = z35.strictObject({
+  folder: z35.enum(["inbox", "sent", "drafts"]).default("inbox"),
   /** The account's address; absent: the default account. */
   account: Address.optional(),
-  unread_only: z34.boolean().default(false),
-  limit: z34.int().min(1).max(200).default(25)
+  unread_only: z35.boolean().default(false),
+  limit: z35.int().min(1).max(200).default(25)
 });
-var OutlookMessage = z34.strictObject({
-  id: z34.string(),
-  subject: z34.string(),
-  sender: z34.string(),
+var OutlookMessage = z35.strictObject({
+  id: z35.string(),
+  subject: z35.string(),
+  sender: z35.string(),
   received_at_ms: epochMs.nullable(),
-  read: z34.boolean(),
-  has_attachments: z34.boolean(),
+  read: z35.boolean(),
+  has_attachments: z35.boolean(),
   /** The first lines of the message's text. */
-  preview: z34.string()
-});
-var OutlookListResult = z34.strictObject({ folder: z34.string(), messages: z34.array(OutlookMessage) });
-var OutlookReadParams = z34.strictObject({ id: z34.string().min(1).max(1024) });
-var OutlookReadResult = z34.strictObject({
-  id: z34.string(),
-  subject: z34.string(),
-  sender: z34.string(),
-  to: z34.array(z34.string()),
-  cc: z34.array(z34.string()),
+  preview: z35.string()
+});
+var OutlookListResult = z35.strictObject({ folder: z35.string(), messages: z35.array(OutlookMessage) });
+var OutlookReadParams = z35.strictObject({ id: z35.string().min(1).max(1024) });
+var OutlookReadResult = z35.strictObject({
+  id: z35.string(),
+  subject: z35.string(),
+  sender: z35.string(),
+  to: z35.array(z35.string()),
+  cc: z35.array(z35.string()),
   received_at_ms: epochMs.nullable(),
   /** The plain text body, cut at 1 MiB. */
-  body: z34.string(),
-  attachments: z34.array(z34.strictObject({ name: z34.string(), size: nonNegInt }))
-});
-var MessagesChatsParams = z34.strictObject({ limit: z34.int().min(1).max(200).default(25) });
-var MessagesChat = z34.strictObject({
-  chat_id: z34.string(),
-  name: z34.string().nullable(),
-  participants: z34.array(z34.string()),
+  body: z35.string(),
+  attachments: z35.array(z35.strictObject({ name: z35.string(), size: nonNegInt }))
+});
+var MessagesChatsParams = z35.strictObject({ limit: z35.int().min(1).max(200).default(25) });
+var MessagesChat = z35.strictObject({
+  chat_id: z35.string(),
+  name: z35.string().nullable(),
+  participants: z35.array(z35.string()),
   last_message_at_ms: epochMs.nullable(),
-  service: z34.string().nullable()
+  service: z35.string().nullable()
 });
-var MessagesChatsResult = z34.strictObject({ chats: z34.array(MessagesChat) });
-var MessagesListParams = z34.strictObject({
+var MessagesChatsResult = z35.strictObject({ chats: z35.array(MessagesChat) });
+var MessagesListParams = z35.strictObject({
   /** One chat (messages.chats' chat_id); absent: the newest across all. */
-  chat_id: z34.string().min(1).max(512).optional(),
-  limit: z34.int().min(1).max(500).default(50)
-});
-var MessagesMessage = z34.strictObject({
-  id: z34.string(),
-  chat_id: z34.string().nullable(),
-  text: z34.string(),
-  from_me: z34.boolean(),
+  chat_id: z35.string().min(1).max(512).optional(),
+  limit: z35.int().min(1).max(500).default(50)
+});
+var MessagesMessage = z35.strictObject({
+  id: z35.string(),
+  chat_id: z35.string().nullable(),
+  text: z35.string(),
+  from_me: z35.boolean(),
   /** The other person's handle (phone or email); null for the person's own messages. */
-  sender: z34.string().nullable(),
+  sender: z35.string().nullable(),
   sent_at_ms: epochMs.nullable()
 });
-var MessagesListResult = z34.strictObject({ messages: z34.array(MessagesMessage) });
-var MessagesSendParams = z34.strictObject({
+var MessagesListResult = z35.strictObject({ messages: z35.array(MessagesMessage) });
+var MessagesSendParams = z35.strictObject({
   /** A phone number or email the person can message. */
-  to: z34.string().min(3).max(320),
-  text: z34.string().min(1).max(2e4),
+  to: z35.string().min(3).max(320),
+  text: z35.string().min(1).max(2e4),
   /**
    * Send only over this service (Matrx Local's SendMessage `service`). Absent: iMessage first, and
    * SMS when the recipient has no iMessage (since 1.42).
    */
-  service: z34.enum(["iMessage", "SMS"]).optional()
+  service: z35.enum(["iMessage", "SMS"]).optional()
 });
-var MessagesSendResult = z34.strictObject({ sent: z34.boolean() });
-var ContactsSearchParams = z34.strictObject({
+var MessagesSendResult = z35.strictObject({ sent: z35.boolean() });
+var ContactsSearchParams = z35.strictObject({
   /** Matched against names, organizations, emails and phone numbers. */
-  query: z34.string().min(1).max(256),
-  limit: z34.int().min(1).max(200).default(25)
+  query: z35.string().min(1).max(256),
+  limit: z35.int().min(1).max(200).default(25)
 });
-var ContactLabeled = z34.strictObject({ label: z34.string().nullable(), value: z34.string() });
-var ContactSummary = z34.strictObject({
-  id: z34.string(),
-  name: z34.string(),
-  organization: z34.string().nullable(),
-  emails: z34.array(ContactLabeled),
-  phones: z34.array(ContactLabeled)
-});
-var ContactsSearchResult = z34.strictObject({ contacts: z34.array(ContactSummary) });
-var ContactsGetParams = z34.strictObject({ id: z34.string().min(1).max(256) });
-var ContactDetail = z34.strictObject({
-  id: z34.string(),
-  name: z34.string(),
-  organization: z34.string().nullable(),
-  job_title: z34.string().nullable(),
-  emails: z34.array(ContactLabeled),
-  phones: z34.array(ContactLabeled),
-  addresses: z34.array(ContactLabeled),
-  birthday: z34.string().nullable(),
-  note: z34.string().nullable()
-});
-var ContactsGetResult = z34.strictObject({ contact: ContactDetail });
-var CalendarListParams = z34.strictObject({
+var ContactLabeled = z35.strictObject({ label: z35.string().nullable(), value: z35.string() });
+var ContactSummary = z35.strictObject({
+  id: z35.string(),
+  name: z35.string(),
+  organization: z35.string().nullable(),
+  emails: z35.array(ContactLabeled),
+  phones: z35.array(ContactLabeled)
+});
+var ContactsSearchResult = z35.strictObject({ contacts: z35.array(ContactSummary) });
+var ContactsGetParams = z35.strictObject({ id: z35.string().min(1).max(256) });
+var ContactDetail = z35.strictObject({
+  id: z35.string(),
+  name: z35.string(),
+  organization: z35.string().nullable(),
+  job_title: z35.string().nullable(),
+  emails: z35.array(ContactLabeled),
+  phones: z35.array(ContactLabeled),
+  addresses: z35.array(ContactLabeled),
+  birthday: z35.string().nullable(),
+  note: z35.string().nullable()
+});
+var ContactsGetResult = z35.strictObject({ contact: ContactDetail });
+var CalendarListParams = z35.strictObject({
   from_ms: epochMs,
   to_ms: epochMs,
   /** One calendar's name; absent: every calendar. */
-  calendar: z34.string().min(1).max(256).optional(),
-  limit: z34.int().min(1).max(500).default(100)
+  calendar: z35.string().min(1).max(256).optional(),
+  limit: z35.int().min(1).max(500).default(100)
 });
-var CalendarEvent = z34.strictObject({
-  id: z34.string(),
-  title: z34.string(),
+var CalendarEvent = z35.strictObject({
+  id: z35.string(),
+  title: z35.string(),
   start_ms: epochMs,
   end_ms: epochMs,
-  all_day: z34.boolean(),
-  calendar: z34.string(),
-  location: z34.string().nullable(),
-  notes: z34.string().nullable()
-});
-var CalendarListResult = z34.strictObject({ events: z34.array(CalendarEvent) });
-var CalendarCreateParams = z34.strictObject({
-  title: z34.string().min(1).max(1024),
+  all_day: z35.boolean(),
+  calendar: z35.string(),
+  location: z35.string().nullable(),
+  notes: z35.string().nullable()
+});
+var CalendarListResult = z35.strictObject({ events: z35.array(CalendarEvent) });
+var CalendarCreateParams = z35.strictObject({
+  title: z35.string().min(1).max(1024),
   start_ms: epochMs,
   end_ms: epochMs,
-  all_day: z34.boolean().default(false),
+  all_day: z35.boolean().default(false),
   /** The calendar's name; absent: the first writable calendar. */
-  calendar: z34.string().min(1).max(256).optional(),
-  location: z34.string().max(1024).optional(),
+  calendar: z35.string().min(1).max(256).optional(),
+  location: z35.string().max(1024).optional(),
   notes: Text.optional()
 });
-var CalendarCreateResult = z34.strictObject({ id: z34.string(), calendar: z34.string() });
-var RemindersListParams = z34.strictObject({
+var CalendarCreateResult = z35.strictObject({ id: z35.string(), calendar: z35.string() });
+var RemindersListParams = z35.strictObject({
   /** One list's name; absent: every list. */
-  list: z34.string().min(1).max(256).optional(),
-  include_completed: z34.boolean().default(false),
-  limit: z34.int().min(1).max(500).default(100)
-});
-var Reminder = z34.strictObject({
-  id: z34.string(),
-  title: z34.string(),
-  list: z34.string(),
+  list: z35.string().min(1).max(256).optional(),
+  include_completed: z35.boolean().default(false),
+  limit: z35.int().min(1).max(500).default(100)
+});
+var Reminder = z35.strictObject({
+  id: z35.string(),
+  title: z35.string(),
+  list: z35.string(),
   due_ms: epochMs.nullable(),
-  completed: z34.boolean(),
-  notes: z34.string().nullable()
+  completed: z35.boolean(),
+  notes: z35.string().nullable()
 });
-var RemindersListResult = z34.strictObject({ reminders: z34.array(Reminder) });
-var RemindersCreateParams = z34.strictObject({
-  title: z34.string().min(1).max(1024),
+var RemindersListResult = z35.strictObject({ reminders: z35.array(Reminder) });
+var RemindersCreateParams = z35.strictObject({
+  title: z35.string().min(1).max(1024),
   due_ms: epochMs.optional(),
-  list: z34.string().min(1).max(256).optional(),
+  list: z35.string().min(1).max(256).optional(),
   notes: Text.optional()
 });
-var RemindersCreateResult = z34.strictObject({ id: z34.string(), list: z34.string() });
-var PhotosSearchParams = z34.strictObject({
+var RemindersCreateResult = z35.strictObject({ id: z35.string(), list: z35.string() });
+var PhotosSearchParams = z35.strictObject({
   /** Matched against file names, titles, descriptions and keywords; absent: the newest. */
-  query: z34.string().min(1).max(256).optional(),
+  query: z35.string().min(1).max(256).optional(),
   from_ms: epochMs.optional(),
   to_ms: epochMs.optional(),
-  favorites_only: z34.boolean().default(false),
-  limit: z34.int().min(1).max(200).default(25)
+  favorites_only: z35.boolean().default(false),
+  limit: z35.int().min(1).max(200).default(25)
 });
-var Photo = z34.strictObject({
-  id: z34.string(),
-  filename: z34.string(),
+var Photo = z35.strictObject({
+  id: z35.string(),
+  filename: z35.string(),
   taken_at_ms: epochMs.nullable(),
   width: nonNegInt.nullable(),
   height: nonNegInt.nullable(),
-  favorite: z34.boolean(),
-  title: z34.string().nullable()
+  favorite: z35.boolean(),
+  title: z35.string().nullable()
 });
-var PhotosSearchResult = z34.strictObject({ photos: z34.array(Photo) });
-var PhotosGetParams = z34.strictObject({
-  id: z34.string().min(1).max(256),
+var PhotosSearchResult = z35.strictObject({ photos: z35.array(Photo) });
+var PhotosGetParams = z35.strictObject({
+  id: z35.string().min(1).max(256),
   /** Copy the original into a folder Matrx 2 owns and answer its path (then fs_read or desktop_documents reads it). */
-  export: z34.boolean().default(false)
+  export: z35.boolean().default(false)
 });
-var PhotosGetResult = z34.strictObject({ photo: Photo, path: z34.string().nullable() });
-var LocationGetParams = z34.strictObject({ timeout_s: z34.int().min(1).max(60).default(15) });
-var LocationGetResult = z34.strictObject({
-  latitude: z34.number().min(-90).max(90),
-  longitude: z34.number().min(-180).max(180),
+var PhotosGetResult = z35.strictObject({ photo: Photo, path: z35.string().nullable() });
+var LocationGetParams = z35.strictObject({ timeout_s: z35.int().min(1).max(60).default(15) });
+var LocationGetResult = z35.strictObject({
+  latitude: z35.number().min(-90).max(90),
+  longitude: z35.number().min(-180).max(180),
   /** Metres; null where the OS does not say. */
-  accuracy_m: z34.number().min(0).nullable(),
+  accuracy_m: z35.number().min(0).nullable(),
   at_ms: epochMs,
   /** Who answered: the OS's own location service. */
-  source: z34.enum(["corelocation", "windows", "geoclue"])
+  source: z35.enum(["corelocation", "windows", "geoclue"])
 });
 
 // src/schema/windows.ts
-import { z as z35 } from "zod";
-var RegistryKey = z35.string().min(6).max(1024).regex(/^(HKLM|HKCU|HKCR|HKU|HKCC|HKEY_LOCAL_MACHINE|HKEY_CURRENT_USER|HKEY_CLASSES_ROOT|HKEY_USERS|HKEY_CURRENT_CONFIG)(\\.*)?$/);
-var RegistryValueType = z35.enum(["REG_SZ", "REG_EXPAND_SZ", "REG_MULTI_SZ", "REG_DWORD", "REG_QWORD", "REG_BINARY", "REG_NONE"]);
-var WindowsRegistryReadParams = z35.strictObject({
+import { z as z36 } from "zod";
+var RegistryKey = z36.string().min(6).max(1024).regex(/^(HKLM|HKCU|HKCR|HKU|HKCC|HKEY_LOCAL_MACHINE|HKEY_CURRENT_USER|HKEY_CLASSES_ROOT|HKEY_USERS|HKEY_CURRENT_CONFIG)(\\.*)?$/);
+var RegistryValueType = z36.enum(["REG_SZ", "REG_EXPAND_SZ", "REG_MULTI_SZ", "REG_DWORD", "REG_QWORD", "REG_BINARY", "REG_NONE"]);
+var WindowsRegistryReadParams = z36.strictObject({
   key: RegistryKey,
   /** One value's name ("" is the key's default value); absent: every value and the subkeys. */
-  name: z35.string().max(16383).optional()
+  name: z36.string().max(16383).optional()
 });
-var RegistryValue = z35.strictObject({ name: z35.string(), type: RegistryValueType, data: z35.string() });
-var WindowsRegistryReadResult = z35.strictObject({
-  key: z35.string(),
-  exists: z35.boolean(),
-  values: z35.array(RegistryValue),
-  subkeys: z35.array(z35.string())
+var RegistryValue = z36.strictObject({ name: z36.string(), type: RegistryValueType, data: z36.string() });
+var WindowsRegistryReadResult = z36.strictObject({
+  key: z36.string(),
+  exists: z36.boolean(),
+  values: z36.array(RegistryValue),
+  subkeys: z36.array(z36.string())
 });
-var WindowsRegistryWriteParams = z35.strictObject({
+var WindowsRegistryWriteParams = z36.strictObject({
   key: RegistryKey,
-  name: z35.string().max(16383),
+  name: z36.string().max(16383),
   type: RegistryValueType.default("REG_SZ"),
   /** As reg.exe takes it: text, a number, hex for binary, \\0 between the strings of a multi-string. */
-  data: z35.string().max(1048576),
+  data: z36.string().max(1048576),
   /** Remove the value instead of writing it. */
-  delete: z35.boolean().default(false)
+  delete: z36.boolean().default(false)
 });
-var WindowsRegistryWriteResult = z35.strictObject({ key: z35.string(), name: z35.string(), deleted: z35.boolean() });
-var WindowsServicesParams = z35.strictObject({
+var WindowsRegistryWriteResult = z36.strictObject({ key: z36.string(), name: z36.string(), deleted: z36.boolean() });
+var WindowsServicesParams = z36.strictObject({
   /** Matched against the service's name and display name. */
-  filter: z35.string().min(1).max(256).optional(),
-  limit: z35.int().min(1).max(1e3).default(200)
+  filter: z36.string().min(1).max(256).optional(),
+  limit: z36.int().min(1).max(1e3).default(200)
 });
-var WindowsService = z35.strictObject({
-  name: z35.string(),
-  display_name: z35.string(),
+var WindowsService = z36.strictObject({
+  name: z36.string(),
+  display_name: z36.string(),
   /** Running, Stopped, Paused… as Windows says it. */
-  status: z35.string(),
+  status: z36.string(),
   /** Automatic, Manual, Disabled…; null where Windows does not say. */
-  start_type: z35.string().nullable()
+  start_type: z36.string().nullable()
 });
-var WindowsServicesResult = z35.strictObject({ services: z35.array(WindowsService) });
-var WindowsServiceControlParams = z35.strictObject({
-  name: z35.string().min(1).max(256),
-  action: z35.enum(["start", "stop", "restart"])
+var WindowsServicesResult = z36.strictObject({ services: z36.array(WindowsService) });
+var WindowsServiceControlParams = z36.strictObject({
+  name: z36.string().min(1).max(256),
+  action: z36.enum(["start", "stop", "restart"])
 });
-var WindowsServiceControlResult = z35.strictObject({ name: z35.string(), status: z35.string() });
-var WindowsEventLogParams = z35.strictObject({
-  log: z35.string().min(1).max(256).default("System"),
+var WindowsServiceControlResult = z36.strictObject({ name: z36.string(), status: z36.string() });
+var WindowsEventLogParams = z36.strictObject({
+  log: z36.string().min(1).max(256).default("System"),
   /** Only these levels; absent: all. */
-  levels: z35.array(z35.enum(["critical", "error", "warning", "information", "verbose"])).max(5).optional(),
+  levels: z36.array(z36.enum(["critical", "error", "warning", "information", "verbose"])).max(5).optional(),
   since_ms: epochMs.optional(),
-  limit: z35.int().min(1).max(500).default(50)
+  limit: z36.int().min(1).max(500).default(50)
 });
-var WindowsEvent = z35.strictObject({
-  id: z35.int(),
-  level: z35.string(),
-  source: z35.string(),
+var WindowsEvent = z36.strictObject({
+  id: z36.int(),
+  level: z36.string(),
+  source: z36.string(),
   at_ms: epochMs,
-  message: z35.string()
+  message: z36.string()
 });
-var WindowsEventLogResult = z35.strictObject({ log: z35.string(), events: z35.array(WindowsEvent) });
-var WindowsFeaturesParams = z35.strictObject({ filter: z35.string().min(1).max(256).optional() });
-var WindowsFeature = z35.strictObject({ name: z35.string(), state: z35.string() });
-var WindowsFeaturesResult = z35.strictObject({ features: z35.array(WindowsFeature) });
+var WindowsEventLogResult = z36.strictObject({ log: z36.string(), events: z36.array(WindowsEvent) });
+var WindowsFeaturesParams = z36.strictObject({ filter: z36.string().min(1).max(256).optional() });
+var WindowsFeature = z36.strictObject({ name: z36.string(), state: z36.string() });
+var WindowsFeaturesResult = z36.strictObject({ features: z36.array(WindowsFeature) });
 
 // src/schema/schedule.ts
-import { z as z36 } from "zod";
-var OpRef = z36.string().min(3).max(128).regex(/^[a-z_]+(\.[a-z_]+)+$/);
-var ScheduleCreateParams = z36.strictObject({
-  name: z36.string().min(1).max(200),
+import { z as z37 } from "zod";
+var OpRef = z37.string().min(3).max(128).regex(/^[a-z_]+(\.[a-z_]+)+$/);
+var ScheduleCreateParams = z37.strictObject({
+  name: z37.string().min(1).max(200),
   op: OpRef,
   /** The op's params, exactly as the op takes them; checked when the task is created. */
-  params: z36.record(z36.string(), z36.unknown()).default({}),
-  interval_s: z36.int().min(10).max(2592e3),
+  params: z37.record(z37.string(), z37.unknown()).default({}),
+  interval_s: z37.int().min(10).max(2592e3),
   /** Stop after this many runs; absent: until cancelled. */
-  max_runs: z36.int().min(1).max(1e5).optional(),
+  max_runs: z37.int().min(1).max(1e5).optional(),
   /** Run once now, before the first interval. */
-  run_now: z36.boolean().default(false)
+  run_now: z37.boolean().default(false)
 });
-var ScheduleRun = z36.strictObject({
+var ScheduleRun = z37.strictObject({
   at_ms: epochMs,
-  ok: z36.boolean(),
+  ok: z37.boolean(),
   elapsed_ms: nonNegInt,
   /** The error's code and message when the run failed. */
-  error: z36.string().nullable(),
+  error: z37.string().nullable(),
   /** The start of the answer, as JSON (cut at 4 KiB). */
-  result_preview: z36.string().nullable()
+  result_preview: z37.string().nullable()
 });
-var ScheduledTask = z36.strictObject({
-  id: z36.string(),
-  name: z36.string(),
-  op: z36.string(),
-  params: z36.record(z36.string(), z36.unknown()),
+var ScheduledTask = z37.strictObject({
+  id: z37.string(),
+  name: z37.string(),
+  op: z37.string(),
+  params: z37.record(z37.string(), z37.unknown()),
   interval_s: nonNegInt,
   max_runs: nonNegInt.nullable(),
   runs: nonNegInt,
   created_at_ms: epochMs,
   next_run_at_ms: epochMs.nullable(),
   /** active, done (ran max_runs), cancelled. */
-  state: z36.enum(["active", "done", "cancelled"]),
+  state: z37.enum(["active", "done", "cancelled"]),
   /** The newest runs, newest first (at most 10). */
-  recent: z36.array(ScheduleRun)
+  recent: z37.array(ScheduleRun)
 });
-var ScheduleCreateResult = z36.strictObject({ task: ScheduledTask });
-var ScheduleListParams = z36.strictObject({ include_finished: z36.boolean().default(false) });
-var ScheduleListResult = z36.strictObject({ tasks: z36.array(ScheduledTask) });
-var ScheduleCancelParams = z36.strictObject({ id: z36.string().min(1).max(64) });
-var ScheduleCancelResult = z36.strictObject({ task: ScheduledTask });
+var ScheduleCreateResult = z37.strictObject({ task: ScheduledTask });
+var ScheduleListParams = z37.strictObject({ include_finished: z37.boolean().default(false) });
+var ScheduleListResult = z37.strictObject({ tasks: z37.array(ScheduledTask) });
+var ScheduleCancelParams = z37.strictObject({ id: z37.string().min(1).max(64) });
+var ScheduleCancelResult = z37.strictObject({ task: ScheduledTask });
 
 // src/schema/notes.ts
-import { z as z37 } from "zod";
-var NoteFolder = z37.string().min(1).max(512).regex(/^[^/\\:*?"<>|][^\\:*?"<>|]*$/);
-var NotePath = z37.string().min(4).max(1024).regex(/^[^/\\:*?"<>|][^\\:*?"<>|]*\.md$/);
-var NotesFoldersParams = z37.strictObject({});
-var NotesFolder = z37.strictObject({ folder: z37.string(), notes: nonNegInt });
-var NotesFoldersResult = z37.strictObject({
+import { z as z38 } from "zod";
+var NoteFolder = z38.string().min(1).max(512).regex(/^[^/\\:*?"<>|][^\\:*?"<>|]*$/);
+var NotePath = z38.string().min(4).max(1024).regex(/^[^/\\:*?"<>|][^\\:*?"<>|]*\.md$/);
+var NotesFoldersParams = z38.strictObject({});
+var NotesFolder = z38.strictObject({ folder: z38.string(), notes: nonNegInt });
+var NotesFoldersResult = z38.strictObject({
   /** The notes root on this computer. */
-  root: z37.string(),
-  folders: z37.array(NotesFolder)
+  root: z38.string(),
+  folders: z38.array(NotesFolder)
 });
-var NotesListParams = z37.strictObject({
+var NotesListParams = z38.strictObject({
   folder: NoteFolder.optional(),
-  limit: z37.int().min(1).max(2e3).default(500)
+  limit: z38.int().min(1).max(2e3).default(500)
 });
-var NoteEntry = z37.strictObject({
-  path: z37.string(),
-  label: z37.string(),
-  folder: z37.string(),
+var NoteEntry = z38.strictObject({
+  path: z38.string(),
+  label: z38.string(),
+  folder: z38.string(),
   bytes: nonNegInt,
   modified_at_ms: epochMs
 });
-var NotesListResult = z37.strictObject({ root: z37.string(), notes: z37.array(NoteEntry), total: nonNegInt });
-var NotesReadParams = z37.strictObject({ path: NotePath });
-var NotesReadResult = z37.strictObject({
-  path: z37.string(),
-  content: z37.string(),
+var NotesListResult = z38.strictObject({ root: z38.string(), notes: z38.array(NoteEntry), total: nonNegInt });
+var NotesReadParams = z38.strictObject({ path: NotePath });
+var NotesReadResult = z38.strictObject({
+  path: z38.string(),
+  content: z38.string(),
   bytes: nonNegInt,
   modified_at_ms: epochMs,
   /** SHA-256 of the content: pass it back as `if_hash` to write only over this version. */
-  hash: z37.string()
+  hash: z38.string()
 });
-var NotesWriteParams = z37.strictObject({
+var NotesWriteParams = z38.strictObject({
   folder: NoteFolder.default("General"),
   /** The note's name, without ".md". */
-  label: z37.string().min(1).max(200).regex(/^[^/\\:*?"<>|]+$/),
-  content: z37.string().max(10485760),
+  label: z38.string().min(1).max(200).regex(/^[^/\\:*?"<>|]+$/),
+  content: z38.string().max(10485760),
   /** Write only when the note is still this version (notes.read's hash); a change since answers CONFLICT. */
-  if_hash: z37.string().length(64).optional()
+  if_hash: z38.string().length(64).optional()
 });
-var NotesWriteResult = z37.strictObject({ path: z37.string(), bytes: nonNegInt, created: z37.boolean(), hash: z37.string() });
-var NotesSearchParams = z37.strictObject({
-  query: z37.string().min(1).max(512),
-  limit: z37.int().min(1).max(200).default(50)
+var NotesWriteResult = z38.strictObject({ path: z38.string(), bytes: nonNegInt, created: z38.boolean(), hash: z38.string() });
+var NotesSearchParams = z38.strictObject({
+  query: z38.string().min(1).max(512),
+  limit: z38.int().min(1).max(200).default(50)
 });
-var NotesMatch = z37.strictObject({
-  path: z37.string(),
-  label: z37.string(),
-  folder: z37.string(),
+var NotesMatch = z38.strictObject({
+  path: z38.string(),
+  label: z38.string(),
+  folder: z38.string(),
   /** The matching lines (at most five), trimmed. */
-  lines: z37.array(z37.string())
+  lines: z38.array(z38.string())
 });
-var NotesSearchResult = z37.strictObject({ matches: z37.array(NotesMatch), total: nonNegInt });
+var NotesSearchResult = z38.strictObject({ matches: z38.array(NotesMatch), total: nonNegInt });
 
 // src/schema/documents.ts
-import { z as z38 } from "zod";
+import { z as z39 } from "zod";
 var DOCUMENTS_MAX_TEXT_CHARS = 1048576;
-var DocumentsPdfTextParams = z38.strictObject({
+var DocumentsPdfTextParams = z39.strictObject({
   path: AbsPath,
   /** 1-based, inclusive. */
-  first_page: z38.int().min(1).optional(),
-  last_page: z38.int().min(1).optional(),
-  max_chars: z38.int().min(1).max(DOCUMENTS_MAX_TEXT_CHARS).default(2e5)
+  first_page: z39.int().min(1).optional(),
+  last_page: z39.int().min(1).optional(),
+  max_chars: z39.int().min(1).max(DOCUMENTS_MAX_TEXT_CHARS).default(2e5)
 });
-var DocumentsPdfPage = z38.strictObject({ page: z38.int().min(1), text: z38.string() });
-var DocumentsPdfTextResult = z38.strictObject({
+var DocumentsPdfPage = z39.strictObject({ page: z39.int().min(1), text: z39.string() });
+var DocumentsPdfTextResult = z39.strictObject({
   pages: nonNegInt,
   /** Each page read, in order (an image-only page has empty text: OCR it). */
-  read: z38.array(DocumentsPdfPage),
-  truncated: z38.boolean(),
-  title: z38.string().nullable(),
-  author: z38.string().nullable()
+  read: z39.array(DocumentsPdfPage),
+  truncated: z39.boolean(),
+  title: z39.string().nullable(),
+  author: z39.string().nullable()
 });
-var DocumentsOcrParams = z38.strictObject({
+var DocumentsOcrParams = z39.strictObject({
   path: AbsPath,
   /** BCP-47 language hints ("en-US", "fr-FR"); absent: the OS's own choice. */
-  languages: z38.array(z38.string().min(2).max(16)).max(8).optional(),
+  languages: z39.array(z39.string().min(2).max(16)).max(8).optional(),
   /** Faster, less accurate. */
-  fast: z38.boolean().default(false)
+  fast: z39.boolean().default(false)
 });
-var DocumentsOcrLine = z38.strictObject({
-  text: z38.string(),
+var DocumentsOcrLine = z39.strictObject({
+  text: z39.string(),
   /** 0–1; null where the engine does not say. */
-  confidence: z38.number().min(0).max(1).nullable()
+  confidence: z39.number().min(0).max(1).nullable()
 });
-var DocumentsOcrResult = z38.strictObject({
-  text: z38.string(),
-  lines: z38.array(DocumentsOcrLine),
-  truncated: z38.boolean(),
+var DocumentsOcrResult = z39.strictObject({
+  text: z39.string(),
+  lines: z39.array(DocumentsOcrLine),
+  truncated: z39.boolean(),
   /** Which engine read it ("vision" on macOS, "windows-ocr", "tesseract"). */
-  engine: z38.string()
+  engine: z39.string()
 });
-var DocumentsImageResizeParams = z38.strictObject({
+var DocumentsImageResizeParams = z39.strictObject({
   path: AbsPath,
   /** Where to write it; absent: next to the original, "<name>-resized.<ext>". */
   out_path: AbsPath.optional(),
   /** The longest side, kept in proportion; absent: the size stays (a format change only). */
-  max_size: z38.int().min(1).max(32768).optional(),
-  format: z38.enum(["png", "jpeg", "tiff", "heic", "bmp", "gif"]).optional(),
-  overwrite: z38.boolean().default(false)
+  max_size: z39.int().min(1).max(32768).optional(),
+  format: z39.enum(["png", "jpeg", "tiff", "heic", "bmp", "gif"]).optional(),
+  overwrite: z39.boolean().default(false)
 });
-var DocumentsImageResizeResult = z38.strictObject({
-  path: z38.string(),
+var DocumentsImageResizeResult = z39.strictObject({
+  path: z39.string(),
   width: nonNegInt,
   height: nonNegInt,
   bytes: nonNegInt
 });
-var DocumentsParagraph = z38.strictObject({
-  style: z38.enum(["title", "heading1", "heading2", "heading3", "body", "bullet", "numbered", "quote", "code"]).default("body"),
-  text: z38.string().max(1e5)
+var DocumentsParagraph = z39.strictObject({
+  style: z39.enum(["title", "heading1", "heading2", "heading3", "body", "bullet", "numbered", "quote", "code"]).default("body"),
+  text: z39.string().max(1e5)
 });
-var DocumentsSheet = z38.strictObject({
-  name: z38.string().min(1).max(31),
+var DocumentsSheet = z39.strictObject({
+  name: z39.string().min(1).max(31),
   /** Rows of cells; the first row is the header when `header` is true. */
-  rows: z38.array(z38.array(z38.union([z38.string().max(32767), z38.number(), z38.boolean(), z38.null()])).max(16384)).max(1e5),
-  header: z38.boolean().default(true)
+  rows: z39.array(z39.array(z39.union([z39.string().max(32767), z39.number(), z39.boolean(), z39.null()])).max(16384)).max(1e5),
+  header: z39.boolean().default(true)
 });
-var DocumentsOfficeGenerateParams = z38.strictObject({
-  kind: z38.enum(["docx", "xlsx"]),
+var DocumentsOfficeGenerateParams = z39.strictObject({
+  kind: z39.enum(["docx", "xlsx"]),
   path: AbsPath,
-  title: z38.string().max(1024).optional(),
+  title: z39.string().max(1024).optional(),
   /** docx: the document's paragraphs, in order. */
-  paragraphs: z38.array(DocumentsParagraph).max(5e4).optional(),
+  paragraphs: z39.array(DocumentsParagraph).max(5e4).optional(),
   /** xlsx: the workbook's sheets, in order. */
-  sheets: z38.array(DocumentsSheet).min(1).max(64).optional(),
-  overwrite: z38.boolean().default(false)
+  sheets: z39.array(DocumentsSheet).min(1).max(64).optional(),
+  overwrite: z39.boolean().default(false)
 });
-var DocumentsOfficeGenerateResult = z38.strictObject({ path: z38.string(), bytes: nonNegInt });
-var EntitiesNerParams = z38.strictObject({
-  text: z38.string().min(1).max(DOCUMENTS_MAX_TEXT_CHARS),
+var DocumentsOfficeGenerateResult = z39.strictObject({ path: z39.string(), bytes: nonNegInt });
+var EntitiesNerParams = z39.strictObject({
+  text: z39.string().min(1).max(DOCUMENTS_MAX_TEXT_CHARS),
   /** Which kinds to keep; absent: all three. */
-  labels: z38.array(z38.enum(["person", "place", "organization"])).min(1).max(3).optional()
+  labels: z39.array(z39.enum(["person", "place", "organization"])).min(1).max(3).optional()
 });
-var EntitySpan = z38.strictObject({
-  text: z38.string(),
-  label: z38.string(),
+var EntitySpan = z39.strictObject({
+  text: z39.string(),
+  label: z39.string(),
   /** Character offsets into the text (UTF-16, as JavaScript counts). */
   start: nonNegInt,
   end: nonNegInt
 });
-var EntitiesNerResult = z38.strictObject({ entities: z38.array(EntitySpan), engine: z38.string() });
-var PiiKind = z38.enum(["email", "phone", "credit_card", "us_ssn", "iban", "ip_address", "url", "api_key"]);
-var EntitiesPiiParams = z38.strictObject({
-  text: z38.string().min(1).max(DOCUMENTS_MAX_TEXT_CHARS),
-  kinds: z38.array(PiiKind).min(1).max(8).optional(),
+var EntitiesNerResult = z39.strictObject({ entities: z39.array(EntitySpan), engine: z39.string() });
+var PiiKind = z39.enum(["email", "phone", "credit_card", "us_ssn", "iban", "ip_address", "url", "api_key"]);
+var EntitiesPiiParams = z39.strictObject({
+  text: z39.string().min(1).max(DOCUMENTS_MAX_TEXT_CHARS),
+  kinds: z39.array(PiiKind).min(1).max(8).optional(),
   /** Also answer the text with each finding replaced by its kind ("[email]"). */
-  redact: z38.boolean().default(false)
+  redact: z39.boolean().default(false)
 });
-var EntitiesPiiResult = z38.strictObject({
-  findings: z38.array(z38.strictObject({ kind: PiiKind, text: z38.string(), start: nonNegInt, end: nonNegInt })),
-  redacted: z38.string().nullable()
+var EntitiesPiiResult = z39.strictObject({
+  findings: z39.array(z39.strictObject({ kind: PiiKind, text: z39.string(), start: nonNegInt, end: nonNegInt })),
+  redacted: z39.string().nullable()
 });
 
 // src/schema/registry.ts
@@ -4181,6 +4263,9 @@ var OPS = {
   "apps.windows.refresh_usage": { params: AppsWindowsRefreshUsageParams, result: AppsWindowActionResult, kind: "unary", since: "1.10", errors: ["NOT_FOUND", "TIMEOUT", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
   "apps.accounts.usage": { params: AppsAccountsUsageParams, result: AppsAccountsUsageResult, kind: "unary", since: "1.10", errors: ["NOT_FOUND", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
   "apps.accounts.resets": { params: AppsAccountsResetsParams, result: AppsAccountsResetsResult, kind: "unary", since: "1.10", errors: ["NOT_FOUND", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  // 1.47: instances and accounts kept apart — an account's usage is the account's, every instance shows it by id.
+  "apps.instances.list": { params: AppsInstancesListParams, result: AppsInstancesListResult, kind: "unary", since: "1.47", errors: ["NOT_FOUND", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "apps.accounts.list": { params: AppsAccountsListParams, result: AppsAccountsListResult, kind: "unary", since: "1.47", errors: ["NOT_FOUND", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
   "apps.projects.move": { params: AppsProjectsMoveParams, result: AppsProjectsMoveResult, kind: "unary", since: "1.10", errors: ["NOT_FOUND", "INVALID_PARAMS", "CONFLICT", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
   "apps.projects.create": { params: AppsProjectsCreateParams, result: AppsProjectsCreateResult, kind: "unary", since: "1.10", errors: ["INVALID_PARAMS", "CONFLICT", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
   "apps.projects.import_pins": { params: AppsProjectsImportPinsParams, result: AppsProjectsImportPinsResult, kind: "unary", since: "1.10", errors: ["CONFLICT", "PLATFORM_UNSUPPORTED", "INTERNAL"] },