@ashx-j/lunr-dev 0.2.19-dev.10.1 → 0.2.21-dev.12.1

package/dist/node-runtime/{update-cli-I6OVDRPL.js → update-cli-NM7B4CKL.js}

@@ -6,9 +6,10 @@ import {
 import "./chunk-DVGWF6A2.js";
 import {
   SettingsManager
-} from "./chunk-5NWQCSKR.js";
+} from "./chunk-VQ4UBWSA.js";
 import "./chunk-URD2SLIT.js";
-import "./chunk-5OLJGVCB.js";
+import "./chunk-LISUTZS3.js";
+import "./chunk-3ONQTOMR.js";
 import "./chunk-AY6CAJSL.js";
 import {
   APP_NAME,

package/dist/node-runtime/{video-extract-ETA5RA7U.js → video-extract-OYT5WKS5.js}

@@ -11,8 +11,8 @@ import {
 } from "./chunk-3WFAEVKS.js";
 import {
   extractHeadingTitle
-} from "./chunk-J7QGQD45.js";
-import "./chunk-4SJWFTUP.js";
+} from "./chunk-WJVFOIB5.js";
+import "./chunk-7NBZ5P7I.js";
 import {
   activityMonitor
 } from "./chunk-DAPBPCBP.js";

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

@@ -0,0 +1,468 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  assertOwnedPath
+} from "./chunk-JZHEUQRL.js";
+import {
+  computerSchemas
+} from "./chunk-H2BI7G7T.js";
+import {
+  require_proper_lockfile
+} from "./chunk-URD2SLIT.js";
+import "./chunk-PL6JKXWI.js";
+import {
+  resizeImage
+} from "./chunk-VTPM5V35.js";
+import {
+  loadPhoton
+} from "./chunk-RQ2Q5IYR.js";
+import "./chunk-PCIGF2XK.js";
+import "./chunk-Q4Q6D4IY.js";
+import {
+  __toESM
+} from "./chunk-BRJX2PRC.js";
+
+// packages/coding-agent/dist/core/computer-use/workflow.js
+import { createHash, randomUUID as randomUUID2 } from "node:crypto";
+
+// packages/coding-agent/dist/core/computer-use/image.js
+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");
+  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.");
+      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
+  });
+  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.");
+  return {
+    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 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 || 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 || data.code === "window_target_mismatch" || 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];
+    typeof value == "string" ? result[key] = value.slice(0, 240) : (typeof value == "boolean" || typeof value == "number" && Number.isFinite(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: typeof data.retryable == "boolean" ? data.retryable : void 0,
+    retry_from_character: validDelivered && data.retry_from_character === delivered ? delivered : void 0
+  };
+}
+function outcome(reply, text) {
+  let data = driverData(reply), message = Array.isArray(reply.content) ? reply.content.find((item) => item.type === "text" && typeof item.text == "string") : void 0;
+  return {
+    ...select(data, ["status", "effect", "refusal", "error", "code", "path", "verified", "verify", "success", "activated"]),
+    refusal: typeof data.refusal == "object" && data.refusal !== null ? select(record(data.refusal), ["code", "message", "facility"]) : select(data, ["refusal"]).refusal,
+    error: typeof data.error == "object" && data.error !== null ? select(record(data.error), ["code", "message", "facility"]) : select(data, ["error"]).error,
+    message: Object.keys(data).length === 0 && message?.type === "text" ? String(message.text).slice(0, 240) : void 0,
+    escalation: record(data.escalation).recommended === "foreground" ? "foreground" : void 0,
+    input: driverRefused(reply) ? "refused_or_failed" : "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();
+  });
+}
+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 || previous.token !== input.observation || !sameTarget(previous.target, targetFrom(input)) || Date.now() - previous.time > 3e4)
+      throw new Error("Stale observation. Capture this exact target again before acting.");
+    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 Error(`Capture refused: ${JSON.stringify(outcome(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 Error("Capture must return exactly one screenshot.");
+    let image = { type: "image", data: images[0].data, mimeType: images[0].mimeType }, dimensions = screenshotDimensions(image);
+    if (data.screenshot_frame_valid === !1 || data.screenshot_error != null || dimensions.width !== data.screenshot_width || dimensions.height !== data.screenshot_height)
+      throw new Error("Screenshot dimensions or frame could not be verified. Capture again.");
+    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 Error("Target geometry changed. Capture a full image before selecting a crop.");
+    let prepared = await abortable(prepareComputerImage(image, crop), signal);
+    return signal.throwIfAborted(), {
+      ...prepared,
+      token: randomUUID2(),
+      target,
+      time,
+      geometry,
+      fingerprint: createHash("sha256").update(image.data).digest("hex")
+    };
+  }
+  imageResult(observation, extra = {}) {
+    this.observation = observation;
+    let { width, height, region, sourceWidth, sourceHeight, scaleX, scaleY, target, token } = observation;
+    return {
+      content: [{ type: "text", text: JSON.stringify({
+        ...extra,
+        observation: token,
+        target,
+        image: { width, height },
+        mapping: { sourceWidth, sourceHeight, ...region, scaleX, scaleY },
+        coordinates: "Use returned-image pixels; mapping is applied automatically."
+      }) }, observation.image],
+      details: { observation: token },
+      isError: !1
+    };
+  }
+  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" && (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_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.");
+        operation = input.keys === void 0 ? "press_key" : "hotkey", 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] : []]);
+    try {
+      let result = await this.lease.run(async () => {
+        if (!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.");
+        let previous = this.observation;
+        if (this.observation = void 0, name === "computer_apps" || name === "computer_launch") {
+          let operation2 = name === "computer_launch" ? "launch_app" : input.pid === void 0 ? "list_apps" : "list_windows", 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 }, reply2 = await abortable(this.driver.call(operation2, args2, combined), combined), data = driverData(reply2), rows = data.apps ?? data.windows, 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;
+          return { content: [{ type: "text", text: JSON.stringify({
+            ...outcome(reply2),
+            ...select(data, ["pid", "window_id", "name", "title"]),
+            items: metadata,
+            offset,
+            total: Array.isArray(rows) ? rows.length : void 0,
+            omitted: remaining || void 0,
+            next_offset: remaining ? offset + 50 : void 0,
+            guidance: name === "computer_launch" ? "Capture the exact target before input." : remaining ? "Pass next_offset as offset with the same pid selection. Lists refresh per call." : void 0
+          }) }], details: {}, isError: driverRefused(reply2) };
+        }
+        let target = targetFrom(input);
+        if (name === "computer_observe") {
+          let crop = input.crop === void 0 ? void 0 : this.crop(input, this.fresh(input, previous)), 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: "Three captures are unchanged. Workflow stopped; stop polling and reconsider the target or approach. No input token issued." }],
+            details: {},
+            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.");
+        let reply = await abortable(this.driver.call(operation, args, combined), combined);
+        combined.throwIfAborted();
+        let actionOutcome = outcome(reply, name === "computer_text" ? input.text : void 0), recoveryGuidance = "retry_from_character" in actionOutcome && 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;
+        if (driverRefused(reply))
+          return { content: [{ type: "text", text: JSON.stringify({
+            ...actionOutcome,
+            guidance: recoveryGuidance ?? "Capture again before deciding; never retry input blindly."
+          }) }], details: {}, isError: !0 };
+        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: 0 }, this.imageResult(after, {
+            ...actionOutcome,
+            unchanged,
+            guidance: recoveryGuidance ?? (unchanged ? "No visible change; this does not prove failure. Do not repeat input blindly." : "Inspect the post-action image to verify the intended effect.")
+          });
+        } catch (error) {
+          return combined.throwIfAborted(), { content: [{ type: "text", text: JSON.stringify({
+            ...actionOutcome,
+            observation: "unavailable",
+            guidance: recoveryGuidance ?? "Input may have taken effect. Capture again before deciding; never repeat blindly.",
+            error: error instanceof Error ? error.message.slice(0, 300) : "Post-action capture failed."
+          }) }], details: {}, isError: !0 };
+        }
+      }, combined);
+      return result.isError && await this.close(), result;
+    } catch (error) {
+      throw await this.close(), new Error(`Computer workflow stopped. Input may have taken effect; observe before deciding, never retry blindly. ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  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
+};

package/dist/node-runtime/{youtube-extract-SRVGNN26.js → youtube-extract-TQYKGFGS.js}

@@ -14,8 +14,8 @@ import {
 } from "./chunk-XBWPBZBN.js";
 import {
   extractHeadingTitle
-} from "./chunk-J7QGQD45.js";
-import "./chunk-4SJWFTUP.js";
+} from "./chunk-WJVFOIB5.js";
+import "./chunk-7NBZ5P7I.js";
 import {
   activityMonitor
 } from "./chunk-DAPBPCBP.js";