@ashx-j/lunr 0.2.25 → 0.2.27

package/dist/node-runtime/workflow-ICDI4N3J.js

@@ -0,0 +1,767 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  DriverCallError
+} from "./chunk-FE3WZI7F.js";
+import {
+  computerSchemas
+} from "./chunk-FYIFPFXE.js";
+import "./chunk-VSUEAI7O.js";
+import {
+  assertOwnedPath
+} from "./chunk-ZIQUS5QO.js";
+import "./chunk-BI3DHYCN.js";
+import "./chunk-PL6JKXWI.js";
+import {
+  resizeImage
+} from "./chunk-TCT6PCUR.js";
+import {
+  require_proper_lockfile
+} from "./chunk-URD2SLIT.js";
+import {
+  loadPhoton
+} from "./chunk-RQ2Q5IYR.js";
+import "./chunk-64XTQNLA.js";
+import "./chunk-Q4Q6D4IY.js";
+import {
+  __toESM
+} from "./chunk-BRJX2PRC.js";
+
+// packages/coding-agent/dist/core/computer-use/workflow.js
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { setTimeout as delay } from "node:timers/promises";
+
+// packages/coding-agent/dist/core/computer-use/image.js
+import { createHash } from "node:crypto";
+function screenshotDimensions(image) {
+  if (image.mimeType !== "image/png" || image.data.length > 64 * 1024 * 1024)
+    throw new Error("Expected a bounded PNG screenshot.");
+  let bytes = Buffer.from(image.data, "base64");
+  if (bytes.length < 24 || !bytes.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10])))
+    throw new Error("Invalid screenshot PNG.");
+  let width = bytes.readUInt32BE(16), height = bytes.readUInt32BE(20);
+  if (!width || !height || width > 16384 || height > 16384 || width * height > 4e7)
+    throw new Error("Screenshot dimensions exceed the supported capture budget.");
+  return { width, height };
+}
+async function prepareComputerImage(image, crop) {
+  let source = screenshotDimensions(image), region = crop ?? { x: 0, y: 0, ...source };
+  if (![region.x, region.y, region.width, region.height].every(Number.isInteger) || region.x < 0 || region.y < 0 || region.width < 1 || region.height < 1 || region.x + region.width > source.width || region.y + region.height > source.height)
+    throw new Error("Crop is outside the captured image.");
+  let bytes = Buffer.from(image.data, "base64"), fingerprint;
+  if (crop) {
+    let photon = await loadPhoton();
+    if (!photon)
+      throw new Error("Image processing is unavailable; crop refused.");
+    let original = photon.PhotonImage.new_from_byteslice(bytes);
+    try {
+      if (original.get_width() !== source.width || original.get_height() !== source.height)
+        throw new Error("Decoded screenshot dimensions changed.");
+      fingerprint = createHash("sha256").update(`${source.width}x${source.height}:`).update(original.get_raw_pixels()).digest("hex");
+      let cropped = photon.crop(original, region.x, region.y, region.x + region.width, region.y + region.height);
+      try {
+        bytes = cropped.get_bytes();
+      } finally {
+        cropped.free();
+      }
+    } finally {
+      original.free();
+    }
+  }
+  let ratio = Math.min(1, 1280 / Math.max(region.width, region.height), Math.sqrt(1e6 / (region.width * region.height))), resized = await resizeImage(bytes, "image/png", {
+    maxWidth: Math.max(1, Math.floor(region.width * ratio)),
+    maxHeight: Math.max(1, Math.floor(region.height * ratio)),
+    maxBytes: 1.5 * 1024 * 1024,
+    includePixelFingerprint: !crop
+  });
+  if (!resized || resized.originalWidth !== region.width || resized.originalHeight !== region.height || resized.width < 1 || resized.height < 1 || resized.width > 1280 || resized.height > 1280 || resized.width * resized.height > 1e6)
+    throw new Error("Screenshot could not be decoded within the image budget.");
+  if (fingerprint ??= resized.fingerprint, !fingerprint)
+    throw new Error("Screenshot pixel identity could not be verified.");
+  return {
+    fingerprint,
+    image: { type: "image", data: resized.data, mimeType: resized.mimeType },
+    width: resized.width,
+    height: resized.height,
+    sourceWidth: source.width,
+    sourceHeight: source.height,
+    region,
+    scaleX: region.width / resized.width,
+    scaleY: region.height / resized.height
+  };
+}
+
+// packages/coding-agent/dist/core/computer-use/lease.js
+var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { userInfo } from "node:os";
+import { join } from "node:path";
+var DesktopLease = class {
+  identity = randomUUID();
+  owned = !1;
+  tail = Promise.resolve();
+  closed = !1;
+  controller = new AbortController();
+  get signal() {
+    return this.controller.signal;
+  }
+  directory;
+  constructor(directory = join(userInfo().homedir, ".lunr", "desktop")) {
+    this.directory = directory;
+  }
+  async owner() {
+    try {
+      let value = JSON.parse(await readFile(join(this.directory, "workflow-owner.json"), "utf8"));
+      if (!value || typeof value != "object" || !("pid" in value) || typeof value.pid != "number" || !Number.isInteger(value.pid) || value.pid < 1 || !("identity" in value) || typeof value.identity != "string")
+        throw new Error("Invalid desktop owner record; refusing takeover.");
+      let processes = "processes" in value ? value.processes : [];
+      if (!Array.isArray(processes) || !processes.every((pid) => Number.isInteger(pid) && pid > 0))
+        throw new Error("Invalid runtime owner record; refusing takeover.");
+      return { pid: value.pid, identity: value.identity, processes };
+    } catch (error) {
+      if (error instanceof Error && "code" in error && error.code === "ENOENT")
+        return;
+      throw error;
+    }
+  }
+  async withOwnerLock(operation) {
+    let release = await import_proper_lockfile.default.lock(this.directory, {
+      lockfilePath: join(this.directory, "workflow-acquire.lock"),
+      retries: 0,
+      stale: 1e4
+    });
+    try {
+      await operation();
+    } finally {
+      await release();
+    }
+  }
+  async writeOwner(owner) {
+    let temporary = join(this.directory, `workflow-owner-${randomUUID()}.tmp`);
+    try {
+      await writeFile(temporary, JSON.stringify(owner), { mode: 384, flag: "wx" }), await rename(temporary, join(this.directory, "workflow-owner.json"));
+    } finally {
+      await rm(temporary, { force: !0 });
+    }
+  }
+  async acquire() {
+    await assertOwnedPath(this.directory), await mkdir(this.directory, { recursive: !0, mode: 448 }), await this.withOwnerLock(async () => {
+      let owner = await this.owner();
+      if (owner && [owner.pid, ...owner.processes].some((pid) => {
+        try {
+          return process.kill(pid, 0), !0;
+        } catch (error) {
+          return !(error instanceof Error && "code" in error && error.code === "ESRCH");
+        }
+      }))
+        throw new Error("Desktop busy: another lunR workflow owns this user's desktop. Retry only after it ends.");
+      await this.writeOwner({ pid: process.pid, identity: this.identity }), this.owned = !0;
+    });
+  }
+  async trackProcess(pid) {
+    await this.withOwnerLock(async () => {
+      let owner = await this.owner();
+      if (!owner || owner.identity !== this.identity || !Number.isInteger(pid) || pid < 1)
+        throw new Error("Cannot bind runtime to the desktop lease.");
+      owner.processes.includes(pid) || owner.processes.push(pid), await this.writeOwner(owner);
+    });
+  }
+  run(operation, signal) {
+    let result = this.tail.then(async () => {
+      if (this.closed)
+        throw new Error("Desktop workflow ended. Start a new workflow and observe again.");
+      if (signal?.throwIfAborted(), this.owned || await this.acquire(), (await this.owner())?.identity !== this.identity)
+        throw this.closed = !0, this.controller.abort(new Error("Desktop lease lost.")), new Error("Desktop lease lost. Input refused.");
+      return signal?.throwIfAborted(), operation();
+    });
+    return this.tail = result.catch(() => {
+    }), result;
+  }
+  async close() {
+    this.closed = !0, this.controller.abort(), await this.tail, this.owned && (await this.withOwnerLock(async () => {
+      (await this.owner())?.identity === this.identity && await rm(join(this.directory, "workflow-owner.json"));
+    }), this.owned = !1);
+  }
+};
+
+// packages/coding-agent/dist/core/computer-use/workflow.js
+function driverData(reply) {
+  if (reply.structuredContent && typeof reply.structuredContent == "object" && !Array.isArray(reply.structuredContent))
+    return Object.fromEntries(Object.entries(reply.structuredContent));
+  if (Array.isArray(reply.content)) {
+    for (let item of reply.content)
+      if (!(item.type !== "text" || typeof item.text != "string"))
+        try {
+          let value = JSON.parse(item.text);
+          if (value && typeof value == "object" && !Array.isArray(value))
+            return Object.fromEntries(Object.entries(value));
+        } catch {
+        }
+  }
+  return {};
+}
+function plainLaunchReason(reply) {
+  if (reply.structuredContent || !Array.isArray(reply.content))
+    return;
+  let text = reply.content.find((item) => item.type === "text")?.text;
+  if (typeof text == "string") {
+    if (/^App name lookup for .+ is (?:temporarily unavailable|unavailable).+No app was launched;/s.test(text))
+      return "app_lookup_unavailable";
+    if (/^App .+ was not found in shell:AppsFolder or by Windows PATH\/association lookup:/s.test(text))
+      return "app_not_found";
+    if (/^Launch of .+ timed out after 15s/s.test(text))
+      return "launch_timeout_unknown";
+    if (/^(?:Failed to launch|Task error): /s.test(text))
+      return "launch_native_error_unknown";
+  }
+}
+function driverRefused(reply) {
+  let data = driverData(reply), acknowledged = data.activated === !0 || data.success === !0 || data.verified === !0 || data.effect === "confirmed", uncertain = [data.status, data.effect].some((value) => value === "partial" || value === "unverifiable");
+  return reply.isError === !0 || plainLaunchReason(reply) !== void 0 || data.refusal !== void 0 && data.refusal !== null && data.refusal !== !1 || data.error !== void 0 && data.error !== null && data.error !== !1 || data.effect === "refused" || data.status === "refused" || data.status === "failed" || data.success === !1 || [
+    "window_target_mismatch",
+    "window_target_not_found",
+    "background_unavailable",
+    "foreground_unavailable",
+    "type_text_incomplete",
+    "verification_failed"
+  ].includes(String(data.code)) || data.status !== void 0 && !acknowledged && !uncertain && !["ok", "success", "completed"].includes(String(data.status)) || data.code !== void 0 && data.code !== 0 && !acknowledged && !uncertain;
+}
+function record(value) {
+  return value !== null && typeof value == "object" && !Array.isArray(value) ? Object.fromEntries(Object.entries(value)) : {};
+}
+function select(data, keys) {
+  let result = {};
+  for (let key of keys) {
+    let value = data[key];
+    ["name", "app_name", "title"].includes(key) && typeof value == "string" ? result[key] = value.slice(0, 240) : (["active", "running", "is_on_screen", "minimized"].includes(key) && typeof value == "boolean" || ["pid", "window_id", "x", "y", "width", "height"].includes(key) && typeof value == "number" && Number.isSafeInteger(value)) && (result[key] = value);
+  }
+  return result;
+}
+function typingRecovery(data, text) {
+  if (typeof text != "string")
+    return {};
+  let requested = data.requested_chars, delivered = data.delivered_chars;
+  if (typeof requested != "number" || !Number.isSafeInteger(requested) || requested < 0 || requested > 2e4 || requested !== Array.from(text).length)
+    return {};
+  let validDelivered = typeof delivered == "number" && Number.isSafeInteger(delivered) && delivered >= 0 && delivered <= requested;
+  return {
+    requested_chars: requested,
+    delivered_chars: validDelivered ? delivered : void 0,
+    retryable: validDelivered && data.retry_from_character === delivered && typeof data.retryable == "boolean" ? data.retryable : void 0,
+    retry_from_character: validDelivered && data.retry_from_character === delivered ? delivered : void 0
+  };
+}
+var nativeCodes = /* @__PURE__ */ new Set([
+  "background_unavailable",
+  "background_occluded",
+  "background_uipi_blocked",
+  "window_target_mismatch",
+  "window_target_not_found",
+  "type_text_incomplete",
+  "foreground_unavailable",
+  "foreground_rejected",
+  "stale_target",
+  "target_not_found",
+  "verification_failed",
+  "tool_invocation_failed"
+]);
+function safeCode(value) {
+  return typeof value == "string" && nativeCodes.has(value) ? value : void 0;
+}
+function nativeReason(reply) {
+  let data = driverData(reply), code = safeCode(data.code) ?? safeCode(record(data.refusal).code) ?? safeCode(record(data.error).code) ?? safeCode(data.refusal) ?? safeCode(data.error);
+  return code || (plainLaunchReason(reply) ? plainLaunchReason(reply) : "native_error_unknown");
+}
+function outcome(reply, text) {
+  let data = driverData(reply), refused = driverRefused(reply), partial = data.effect === "partial" || data.status === "partial";
+  return {
+    phase: refused || partial ? "native_result" : "native_request",
+    code: refused || partial ? nativeReason(reply) : void 0,
+    native_code: safeCode(data.code) ?? safeCode(record(data.refusal).code) ?? safeCode(record(data.error).code),
+    status: typeof data.status == "string" && ["ok", "success", "completed", "partial", "refused", "failed"].includes(data.status) ? data.status : void 0,
+    effect: typeof data.effect == "string" && ["confirmed", "partial", "unverifiable", "refused"].includes(data.effect) ? data.effect : void 0,
+    verified: typeof data.verified == "boolean" ? data.verified : void 0,
+    success: typeof data.success == "boolean" ? data.success : void 0,
+    activated: typeof data.activated == "boolean" ? data.activated : void 0,
+    escalation: record(data.escalation).recommended === "foreground" ? "foreground" : void 0,
+    input: partial && typingRecovery(data, text).delivered_chars !== void 0 ? "partial" : refused || partial ? "uncertain" : "dispatched",
+    applicationEffect: "unverified",
+    ...typingRecovery(data, text)
+  };
+}
+function abortable(pending, signal) {
+  return new Promise((resolve, reject) => {
+    let abort = () => {
+      signal.removeEventListener("abort", abort), reject(signal.reason ?? new Error("Computer operation cancelled."));
+    };
+    signal.addEventListener("abort", abort, { once: !0 }), pending.then((value) => {
+      signal.removeEventListener("abort", abort), resolve(value);
+    }, (error) => {
+      signal.removeEventListener("abort", abort), reject(error);
+    }), signal.aborted && abort();
+  });
+}
+var freshActionGuidance = "Get a fresh capture of the exact target before any next action, including window focus. Copy its token exactly. No input was sent by this call; earlier calls may have had an effect.", CaptureError = class extends Error {
+  code;
+  constructor(code) {
+    super(code), this.code = code;
+  }
+}, ObservationError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(`Stale observation. ${message}`), this.code = code;
+  }
+};
+function targetFrom(input) {
+  if (input.desktop === !0) {
+    if (input.pid !== void 0 || input.window_id !== void 0)
+      throw new Error("Desktop target cannot include pid/window_id.");
+    return { desktop: !0 };
+  }
+  if (typeof input.pid != "number" || !Number.isInteger(input.pid) || input.pid < 1 || typeof input.window_id != "number" || !Number.isInteger(input.window_id) || input.window_id < 1)
+    throw new Error("Window target requires positive integer pid and window_id.");
+  return { pid: input.pid, window_id: input.window_id };
+}
+function sameTarget(a, b) {
+  return a.desktop === !0 ? b.desktop === !0 : b.desktop !== !0 && a.pid === b.pid && a.window_id === b.window_id;
+}
+var ComputerWorkflow = class {
+  observation;
+  lastCapture;
+  lastAction;
+  abort = new AbortController();
+  closing;
+  driver;
+  lease;
+  constructor(driver, lease = new DesktopLease()) {
+    this.driver = driver, this.lease = lease, this.driver.setProcessObserver?.((pid) => this.lease.trackProcess(pid));
+  }
+  fresh(input, previous) {
+    if (!previous)
+      throw new ObservationError("observation_unavailable", "No active observation is available.");
+    if (previous.token !== input.observation)
+      throw new ObservationError("observation_mismatch", "Token does not match the active observation.");
+    if (!sameTarget(previous.target, targetFrom(input)))
+      throw new ObservationError("observation_target_mismatch", "Token belongs to a different target.");
+    if (Date.now() - previous.time > 3e4)
+      throw new ObservationError("observation_expired", "The active observation is older than 30 seconds.");
+    return previous;
+  }
+  async capture(target, signal, previous, crop) {
+    let time = Date.now(), reply = await abortable(this.driver.call(target.desktop ? "get_desktop_state" : "get_window_state", target.desktop ? {} : {
+      pid: target.pid,
+      window_id: target.window_id,
+      include_accessibility_tree: !1,
+      include_screenshot: !0,
+      max_dimension: 2560
+    }, signal), signal);
+    if (driverRefused(reply))
+      throw new CaptureError(nativeReason(reply));
+    let data = driverData(reply), images = Array.isArray(reply.content) ? reply.content.filter((item) => item.type === "image") : [];
+    if (images.length !== 1 || typeof images[0].data != "string" || typeof images[0].mimeType != "string")
+      throw new CaptureError("screenshot_unavailable");
+    let image = { type: "image", data: images[0].data, mimeType: images[0].mimeType }, dimensions;
+    try {
+      dimensions = screenshotDimensions(image);
+    } catch {
+      throw new CaptureError("image_decode_failed");
+    }
+    if (data.screenshot_frame_valid === !1 || data.screenshot_error != null || dimensions.width !== data.screenshot_width || dimensions.height !== data.screenshot_height)
+      throw new CaptureError("image_frame_invalid");
+    let geometry = JSON.stringify(select(record(data.window_bounds), ["x", "y", "width", "height"]));
+    if (crop && previous && (previous.sourceWidth !== dimensions.width || previous.sourceHeight !== dimensions.height || previous.geometry !== geometry))
+      throw new CaptureError("target_geometry_changed");
+    let prepared;
+    try {
+      prepared = await abortable(prepareComputerImage(image, crop), signal);
+    } catch (error) {
+      throw signal.aborted ? error : new CaptureError("image_decode_failed");
+    }
+    return signal.throwIfAborted(), { ...prepared, token: randomUUID2(), target, time, fingerprint: prepared.fingerprint, geometry };
+  }
+  imageResult(observation, extra = {}) {
+    this.observation = observation;
+    let { width, height, region, sourceWidth, sourceHeight, scaleX, scaleY, target, token } = observation, failed = extra.failed === !0;
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            ...extra,
+            observation: token,
+            target,
+            captured_at: observation.time,
+            expires_at: observation.time + 3e4,
+            image: { width, height },
+            mapping: { sourceWidth, sourceHeight, ...region, scaleX, scaleY },
+            coordinates: "Use returned-image pixels; mapping is applied automatically."
+          })
+        },
+        observation.image
+      ],
+      details: { observation: token, computer: { failed, workflow: "ready" } },
+      isError: failed
+    };
+  }
+  crop(input, previous) {
+    let crop = record(input.crop), { x, y, width, height } = crop;
+    if (typeof x != "number" || typeof y != "number" || typeof width != "number" || typeof height != "number" || ![x, y, width, height].every(Number.isFinite) || x < 0 || y < 0 || width <= 0 || height <= 0 || x + width > previous.width || y + height > previous.height || Object.keys(crop).some((key) => !["x", "y", "width", "height"].includes(key)))
+      throw new Error("Crop must fit the latest returned image.");
+    let left = Math.floor(previous.region.x + x * previous.scaleX), top = Math.floor(previous.region.y + y * previous.scaleY), right = Math.min(previous.sourceWidth, Math.ceil(previous.region.x + (x + width) * previous.scaleX)), bottom = Math.min(previous.sourceHeight, Math.ceil(previous.region.y + (y + height) * previous.scaleY));
+    return { x: left, y: top, width: right - left, height: bottom - top };
+  }
+  action(name, input, previous) {
+    let args = previous.target.desktop ? { scope: "desktop" } : { pid: previous.target.pid, window_id: previous.target.window_id };
+    if (previous.target.desktop && input.foreground !== !0)
+      throw new Error("Desktop input requires foreground=true.");
+    name !== "computer_window" && name !== "computer_hover" && (args.delivery_mode = input.foreground === !0 ? "foreground" : "background");
+    for (let key of ["x", "y", "from_x", "from_y", "to_x", "to_y"]) {
+      if (name === "computer_window")
+        break;
+      let value = input[key];
+      if (value === void 0)
+        continue;
+      let horizontal = key.endsWith("x");
+      if (typeof value != "number" || !Number.isFinite(value) || value < 0 || value >= (horizontal ? previous.width : previous.height))
+        throw new Error("Coordinate outside the observed image.");
+      args[key] = (horizontal ? previous.region.x : previous.region.y) + value * (horizontal ? previous.scaleX : previous.scaleY);
+    }
+    if (input.x === void 0 != (input.y === void 0))
+      throw new Error("Provide a complete x/y pair.");
+    if (previous.target.desktop && ["computer_key", "computer_text"].includes(name) && input.x !== void 0)
+      throw new Error("Desktop keyboard input uses the observed focused field. Change focus with a separate grounded click.");
+    let operation;
+    switch (name) {
+      case "computer_hover":
+        if (process.platform !== "win32" || !previous.target.desktop || input.desktop !== !0 || input.foreground !== !0 || input.x === void 0 || input.y === void 0)
+          throw new Error("Hover requires a Windows foreground desktop image and x/y coordinates.");
+        operation = "move_cursor";
+        break;
+      case "computer_click":
+      case "computer_scroll":
+        if (input.x === void 0 || input.y === void 0)
+          throw new Error("This action requires x/y image coordinates.");
+        operation = name === "computer_click" ? "click" : "scroll";
+        for (let key of name === "computer_click" ? ["button", "count", "modifier"] : ["direction", "amount", "by"])
+          input[key] !== void 0 && (args[key] = input[key]);
+        break;
+      case "computer_drag":
+        if (!["from_x", "from_y", "to_x", "to_y"].every((key) => typeof args[key] == "number"))
+          throw new Error("Drag requires both endpoints.");
+        operation = "drag";
+        break;
+      case "computer_key": {
+        if (input.key === void 0 == (input.keys === void 0))
+          throw new Error("Provide key OR keys.");
+        let keys = Array.isArray(input.keys) ? input.keys : void 0, last = keys?.at(-1), modifiers = /* @__PURE__ */ new Set(["ctrl", "control", "shift", "alt", "win", "windows", "cmd", "command"]), foregroundShortcut = process.platform === "win32" && input.foreground === !0 && input.x === void 0 && keys !== void 0 && keys.length >= 2 && keys.slice(0, -1).every((key) => typeof key == "string" && modifiers.has(key.toLowerCase())) && typeof last == "string" && !modifiers.has(last.toLowerCase());
+        operation = input.keys === void 0 || foregroundShortcut ? "press_key" : "hotkey", foregroundShortcut ? (args.key = last, args.modifiers = keys.slice(0, -1)) : args[input.keys === void 0 ? "key" : "keys"] = input.keys ?? input.key;
+        break;
+      }
+      case "computer_text":
+        operation = "type_text", args.text = input.text;
+        break;
+      case "computer_window":
+        if (previous.target.desktop)
+          throw new Error("Window management requires an exact window target.");
+        if (input.action === "frame") {
+          for (let key of ["x", "y", "width", "height"]) {
+            let value = input[key];
+            if (typeof value != "number" || !Number.isFinite(value) || ["width", "height"].includes(key) && value <= 0)
+              throw new Error("Frame requires valid x/y/width/height.");
+            args[key] = value;
+          }
+          operation = "set_window_frame";
+        } else if (input.action === "focus" && ["x", "y", "width", "height"].every((key) => input[key] === void 0))
+          operation = "bring_to_front";
+        else
+          throw new Error("Use frame or focus. Minimize/restore uses a fresh image click on the visible control.");
+        break;
+      default:
+        throw new Error("Unknown computer action.");
+    }
+    return { operation, args };
+  }
+  async execute(name, input, signal) {
+    let combined = AbortSignal.any([
+      this.abort.signal,
+      this.lease.signal,
+      AbortSignal.timeout(9e4),
+      ...signal ? [signal] : []
+    ]), inputDispatched = !1, failureCode = "workflow_unavailable", phase = "validation", currentPhase = () => phase, operationName = name, actionTarget, actionOutcome;
+    try {
+      let result = await this.lease.run(async () => {
+        failureCode = "invalid_arguments";
+        let previous = this.observation;
+        if (name !== "computer_apps" && (this.observation = void 0), !Object.hasOwn(computerSchemas, name))
+          throw new Error("Unknown computer operation.");
+        let schema = computerSchemas[name];
+        if (Object.keys(input).some((key) => !Object.hasOwn(schema.properties, key)))
+          throw new Error("Unsupported computer argument. Use image coordinates only.");
+        if (name === "computer_apps" || name === "computer_launch") {
+          let operation2 = name === "computer_launch" ? "launch_app" : input.pid === void 0 ? "list_apps" : "list_windows";
+          if (operationName = operation2, input.include_windows !== void 0 && (name !== "computer_apps" || typeof input.include_windows != "boolean" || input.include_windows && (input.pid !== void 0 || typeof input.query != "string" || !input.query.trim())))
+            throw new Error("include_windows requires a named app query without pid.");
+          if (input.pid !== void 0 && (typeof input.pid != "number" || !Number.isSafeInteger(input.pid) || input.pid < 1))
+            throw new Error("Window lookup requires a positive pid.");
+          if (name === "computer_launch" && (typeof input.name != "string" || !input.name.trim() || input.name.length > 500))
+            throw new Error("Launch requires a nonblank name.");
+          if (input.query !== void 0 && (typeof input.query != "string" || !input.query.trim() || Array.from(input.query).length > 240))
+            throw new Error("Discovery query must be a nonblank string of at most 240 characters.");
+          let query = typeof input.query == "string" ? input.query.trim() : void 0, needle = query?.toLowerCase(), offset = input.offset ?? 0;
+          if (typeof offset != "number" || !Number.isSafeInteger(offset) || offset < 0)
+            throw new Error("Discovery offset must be a nonnegative safe integer.");
+          let args2 = name === "computer_launch" ? { name: input.name } : input.pid === void 0 ? {} : { pid: input.pid };
+          combined.throwIfAborted(), inputDispatched = name === "computer_launch", phase = "native_request", failureCode = "discovery_failed";
+          let reply2 = await abortable(this.driver.call(operation2, args2, combined), combined), data = driverData(reply2), discovered = data.apps ?? data.windows, rows = Array.isArray(discovered) && needle ? discovered.filter((row) => {
+            let item = record(row);
+            return [item.name, item.app_name, item.title].some((value) => typeof value == "string" && value.toLowerCase().includes(needle));
+          }) : discovered, metadata = Array.isArray(rows) ? rows.slice(offset, offset + 50).map((row) => {
+            let item = record(row);
+            return {
+              ...select(item, [
+                "pid",
+                "window_id",
+                "name",
+                "app_name",
+                "title",
+                "active",
+                "running",
+                "is_on_screen",
+                "minimized"
+              ]),
+              bounds: item.bounds ? select(record(item.bounds), ["x", "y", "width", "height"]) : void 0
+            };
+          }) : void 0, remaining = Array.isArray(rows) ? Math.max(0, rows.length - offset - (metadata?.length ?? 0)) : 0, failed2 = driverRefused(reply2), pid = typeof data.pid == "number" && Number.isSafeInteger(data.pid) && data.pid > 0 ? data.pid : void 0, launchWindows = Array.isArray(data.windows) ? data.windows.slice(0, 50).map((row) => {
+            let item = record(row);
+            return {
+              ...select(item, ["window_id", "title", "is_on_screen", "minimized"]),
+              bounds: item.bounds ? select(record(item.bounds), ["x", "y", "width", "height"]) : void 0
+            };
+          }) : [], returnedId = data.window_id ?? (Array.isArray(data.windows) && data.windows.length === 1 ? record(data.windows[0]).window_id : void 0), windowId = typeof returnedId == "number" && Number.isSafeInteger(returnedId) && returnedId > 0 ? returnedId : void 0, windowsByPid, guidance = remaining ? "Pass next_offset as offset with the same pid and query. Lists refresh per call." : input.pid !== void 0 ? "Use computer_observe({pid,window_id}) for an exact returned window." : "App query filters app identities, not every window title. Use computer_apps({pid}) to find windows for a running app.";
+          if (name === "computer_apps" && input.include_windows === !0 && !failed2) {
+            let pids = [
+              ...new Set((Array.isArray(rows) ? rows : []).map((row) => record(row).pid).filter((value) => typeof value == "number" && Number.isSafeInteger(value) && value > 0))
+            ];
+            if (pids.length > 5)
+              guidance = "More than five running processes matched. Narrow the query or choose one positive pid with computer_apps({pid}); no arbitrary process was selected.";
+            else {
+              windowsByPid = [];
+              let budget = 50;
+              for (let matchingPid of pids) {
+                combined.throwIfAborted();
+                try {
+                  let windowsReply = await abortable(this.driver.call("list_windows", { pid: matchingPid }, combined), combined), windows = driverData(windowsReply).windows;
+                  if (driverRefused(windowsReply) || !Array.isArray(windows)) {
+                    windowsByPid.push({
+                      pid: matchingPid,
+                      error: driverRefused(windowsReply) ? nativeReason(windowsReply) : "windows_unavailable"
+                    });
+                    continue;
+                  }
+                  let subset = windows.slice(0, budget).map((row) => {
+                    let item = record(row);
+                    return {
+                      ...select(item, [
+                        "pid",
+                        "window_id",
+                        "name",
+                        "app_name",
+                        "title",
+                        "active",
+                        "running",
+                        "is_on_screen",
+                        "minimized"
+                      ]),
+                      bounds: item.bounds ? select(record(item.bounds), ["x", "y", "width", "height"]) : void 0
+                    };
+                  }), omitted = windows.length - subset.length;
+                  windowsByPid.push({
+                    pid: matchingPid,
+                    windows: subset,
+                    omitted: omitted || void 0,
+                    next_offset: omitted ? subset.length : void 0
+                  }), budget -= subset.length;
+                } catch (error) {
+                  if (combined.aborted || error instanceof DriverCallError)
+                    throw error;
+                  windowsByPid.push({ pid: matchingPid, error: "window_lookup_failed" });
+                }
+              }
+              guidance = "Use computer_observe({pid,window_id}) for a returned window. For omitted windows use computer_apps({pid,offset:next_offset}). Per-PID failures need a targeted lookup.";
+            }
+          }
+          return name === "computer_launch" && (guidance = pid && windowId && !failed2 ? `Use computer_observe({pid:${pid},window_id:${windowId}}) before input.` : `Launch ${failed2 ? "may have completed despite an unsuccessful reply" : "returned no exact window"}. Use computer_apps({${pid ? `pid:${pid}` : `query:${JSON.stringify(input.name)}`}}) before another launch or input.`), {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({
+                  kind: name === "computer_launch" ? "launch" : input.pid === void 0 ? "apps" : "windows",
+                  operation: operation2,
+                  ...name === "computer_launch" ? outcome(reply2) : { phase: "native_result", code: failed2 ? nativeReason(reply2) : void 0 },
+                  input: name === "computer_launch" ? "not_applicable" : void 0,
+                  launch: name === "computer_launch" ? plainLaunchReason(reply2) === "app_lookup_unavailable" ? "not_started" : failed2 ? "completion_uncertain" : "acknowledged" : void 0,
+                  ...select(data, ["pid", "window_id", "name", "title"]),
+                  window_id: name === "computer_launch" ? windowId : select(data, ["window_id"]).window_id,
+                  windows: name === "computer_launch" ? launchWindows : void 0,
+                  items: name === "computer_launch" ? void 0 : metadata,
+                  windows_by_pid: windowsByPid,
+                  query,
+                  offset,
+                  total: Array.isArray(rows) ? rows.length : void 0,
+                  omitted: remaining || void 0,
+                  next_offset: remaining ? offset + 50 : void 0,
+                  guidance
+                })
+              }
+            ],
+            details: { computer: { failed: failed2, workflow: "ready" } },
+            isError: failed2
+          };
+        }
+        let target = targetFrom(input);
+        if (actionTarget = target, name === "computer_observe") {
+          phase = "observation_capture";
+          let crop = input.crop === void 0 ? void 0 : this.crop(input, this.fresh(input, previous));
+          failureCode = "capture_failed";
+          let captured = await this.capture(target, combined, previous, crop), unchanged = this.lastCapture?.fingerprint === captured.fingerprint && sameTarget(this.lastCapture.target, target), repeats = crop ? 0 : unchanged ? (this.lastCapture?.repeats ?? 0) + 1 : 1;
+          return this.lastCapture = { fingerprint: captured.fingerprint, target, repeats }, repeats >= 3 ? {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({
+                  phase: "observation_capture",
+                  code: "unchanged_polling_limit",
+                  guidance: "Three captures are unchanged. Stop polling and reconsider the target or approach. No input token issued."
+                })
+              }
+            ],
+            details: { computer: { failed: !0, workflow: "stopped" } },
+            isError: !0
+          } : this.imageResult(captured, { unchanged });
+        }
+        let grounded = this.fresh(input, previous), { operation, args } = this.action(name, input, grounded), { button = "left", count = 1, modifier = [], ...clickArgs } = args, signature = JSON.stringify({
+          operation,
+          args: operation === "click" ? {
+            ...clickArgs,
+            button,
+            count,
+            modifier: Array.isArray(modifier) ? [...new Set(modifier)].sort() : modifier
+          } : args
+        });
+        if (this.lastAction?.unchanged && this.lastAction.signature === signature && this.lastAction.fingerprint === grounded.fingerprint)
+          throw new Error("The identical action had no visible change. Choose a different grounded action; never retry blindly.");
+        combined.throwIfAborted(), inputDispatched = !0, phase = "native_request", operationName = operation;
+        let reply = await abortable(this.driver.call(operation, args, combined), combined);
+        combined.throwIfAborted(), actionOutcome = outcome(reply, name === "computer_text" ? input.text : void 0);
+        let recoveryGuidance = actionOutcome.retry_from_character !== void 0 ? "Verify the field in a fresh image before considering any remaining suffix. retry_from_character is a zero-based Unicode code-point offset, not UTF-16. retryable is driver advice, not authorization to retry." : void 0, failed = driverRefused(reply) || driverData(reply).effect === "partial" || driverData(reply).status === "partial", backgroundUnavailable = actionOutcome.code === "background_unavailable";
+        name === "computer_hover" && await delay(700, void 0, { signal: combined }), phase = "post_action_capture";
+        try {
+          let after = await this.capture(target, combined), unchanged = after.fingerprint === grounded.fingerprint;
+          return this.lastAction = { signature, fingerprint: after.fingerprint, unchanged }, this.lastCapture = {
+            fingerprint: after.fingerprint,
+            target,
+            repeats: failed && this.lastCapture?.fingerprint === after.fingerprint && sameTarget(this.lastCapture.target, target) ? this.lastCapture.repeats : 0
+          }, this.imageResult(after, {
+            kind: "action",
+            operation,
+            target,
+            ...actionOutcome,
+            failed,
+            unchanged,
+            guidance: [
+              "Inspect the post-action image before another action. No visible change does not prove failure; never repeat blindly.",
+              backgroundUnavailable ? "After this fresh capture, foreground input may be considered if permitted, not another background shortcut." : void 0,
+              recoveryGuidance
+            ].filter(Boolean).join(" ")
+          });
+        } catch (error) {
+          if (combined.throwIfAborted(), !(error instanceof CaptureError))
+            throw error;
+          return this.lastAction = { signature, fingerprint: grounded.fingerprint, unchanged: !0 }, {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({
+                  kind: "action",
+                  operation,
+                  target,
+                  ...actionOutcome,
+                  phase: "post_action_capture",
+                  capture_error: error.code,
+                  observation: "unavailable",
+                  guidance: `Input may have taken effect. ${["target_not_found", "window_target_not_found", "window_target_mismatch"].includes(error.code) ? "Use computer_apps({pid}) or observe the desktop to find the target." : "Get a fresh capture of the exact target"} before another action; never repeat blindly. ${recoveryGuidance ?? ""}`
+                })
+              }
+            ],
+            details: { computer: { failed: !0, workflow: "ready" } },
+            isError: !0
+          };
+        }
+      }, combined);
+      return result.details.computer.workflow !== "ready" ? this.finish(result) : result;
+    } catch (error) {
+      error instanceof DriverCallError && !(currentPhase() === "post_action_capture" && actionOutcome) && (phase = error.phase, inputDispatched = error.dispatched);
+      let failurePhase = currentPhase(), fatal = combined.aborted || this.abort.signal.aborted || this.lease.signal.aborted || error instanceof DriverCallError || !(error instanceof ObservationError || error instanceof CaptureError || failurePhase === "validation" || failurePhase === "observation_capture" && !inputDispatched), code = error instanceof ObservationError || error instanceof CaptureError ? error.code : inputDispatched && failurePhase === "post_action_capture" ? "capture_transport_failed" : error instanceof DriverCallError ? error.dispatched ? "input_dispatch_failed" : "adapter_preflight_failed" : inputDispatched ? "input_dispatch_failed" : failurePhase === "validation" ? "invalid_arguments" : failureCode, message = name === "computer_launch" ? inputDispatched ? "Launch request began; activation may have occurred." : "No launch request was sent by this call." : inputDispatched ? "Input may have taken effect; request began." : "No input was sent by this call.", guidance = inputDispatched ? name === "computer_launch" ? `Use computer_apps({query:${JSON.stringify(input.name)}) before considering another launch.` : `Get a fresh capture of the exact target before another action. Input may have taken effect; inspect the field before deciding and never repeat blindly. ${actionOutcome?.retry_from_character !== void 0 ? "Verify the field in a fresh image before considering any remaining suffix. retry_from_character is a zero-based Unicode code-point offset, not UTF-16." : ""}` : freshActionGuidance, result = {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              kind: name === "computer_apps" ? "apps" : name === "computer_launch" ? "launch" : name === "computer_observe" ? "observation" : "action",
+              operation: operationName,
+              target: actionTarget,
+              ...actionOutcome,
+              action_outcome: actionOutcome,
+              phase: failurePhase,
+              code,
+              input: name === "computer_apps" ? void 0 : name === "computer_launch" ? "not_applicable" : inputDispatched ? "uncertain" : "not_dispatched",
+              request: name === "computer_launch" ? inputDispatched ? "sent" : "not_sent" : void 0,
+              applicationEffect: "unverified",
+              observation: "unavailable",
+              capture_error: failurePhase === "post_action_capture" ? code : void 0,
+              message,
+              guidance
+            })
+          }
+        ],
+        details: { computer: { failed: !0, workflow: fatal ? "stopped" : "ready" } },
+        isError: !0
+      };
+      return fatal ? this.finish(result) : result;
+    }
+  }
+  async finish(result) {
+    try {
+      return await this.close(), {
+        ...result,
+        details: { ...result.details, computer: { failed: result.details.computer.failed, workflow: "stopped" } }
+      };
+    } catch {
+      return {
+        content: [
+          ...result.content,
+          {
+            type: "text",
+            text: JSON.stringify({
+              phase: "cleanup",
+              cleanup: "unconfirmed",
+              guidance: "Desktop ownership retained until shutdown is confirmed."
+            })
+          }
+        ],
+        details: { ...result.details, computer: { failed: !0, workflow: "cleanup_unconfirmed" } },
+        isError: !0
+      };
+    }
+  }
+  close() {
+    return this.abort.abort(), this.observation = void 0, this.closing ??= this.stop(), this.closing;
+  }
+  async stop() {
+    await this.driver.close(), await this.lease.close();
+  }
+};
+export {
+  ComputerWorkflow,
+  driverData,
+  driverRefused
+};