npm - libretto - Versions diffs - 0.6.11 → 0.6.12 - Mend

libretto 0.6.11 → 0.6.12

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (119) hide show

package/README.md +4 -0
package/README.template.md +4 -0
package/dist/cli/cli.js +4 -3
package/dist/cli/commands/ai.js +3 -2
package/dist/cli/commands/browser.js +17 -17
package/dist/cli/commands/execution.js +254 -234
package/dist/cli/commands/experiments.js +100 -0
package/dist/cli/commands/setup.js +20 -34
package/dist/cli/commands/shared.js +10 -0
package/dist/cli/commands/snapshot.js +81 -9
package/dist/cli/commands/status.js +5 -4
package/dist/cli/core/ai-model.js +6 -3
package/dist/cli/core/browser.js +300 -121
package/dist/cli/core/config.js +4 -2
package/dist/cli/core/context.js +4 -0
package/dist/cli/core/daemon/config.js +0 -6
package/dist/cli/core/daemon/daemon.js +535 -89
package/dist/cli/core/daemon/ipc.js +170 -129
package/dist/cli/core/daemon/snapshot.js +72 -6
package/dist/cli/core/experiments.js +66 -0
package/dist/cli/core/session.js +5 -4
package/dist/cli/core/skill-version.js +2 -1
package/dist/cli/core/snapshot-analyzer.js +4 -3
package/dist/cli/core/workflow-runner/runner.js +147 -0
package/dist/cli/core/workflow-runtime.js +60 -0
package/dist/cli/router.js +4 -1
package/dist/shared/debug/pause-handler.d.ts +9 -0
package/dist/shared/debug/pause-handler.js +15 -0
package/dist/shared/debug/pause.d.ts +1 -2
package/dist/shared/debug/pause.js +13 -36
package/dist/shared/ipc/child-process-transport.d.ts +7 -0
package/dist/shared/ipc/child-process-transport.js +60 -0
package/dist/shared/ipc/child-process-transport.spec.d.ts +2 -0
package/dist/shared/ipc/child-process-transport.spec.js +68 -0
package/dist/shared/ipc/ipc.d.ts +46 -0
package/dist/shared/ipc/ipc.js +165 -0
package/dist/shared/ipc/ipc.spec.d.ts +2 -0
package/dist/shared/ipc/ipc.spec.js +114 -0
package/dist/shared/ipc/socket-transport.d.ts +9 -0
package/dist/shared/ipc/socket-transport.js +143 -0
package/dist/shared/ipc/socket-transport.spec.d.ts +2 -0
package/dist/shared/ipc/socket-transport.spec.js +117 -0
package/dist/shared/package-manager.d.ts +7 -0
package/dist/shared/package-manager.js +60 -0
package/dist/shared/paths/paths.d.ts +1 -8
package/dist/shared/paths/paths.js +1 -49
package/dist/shared/snapshot/capture-snapshot.d.ts +9 -0
package/dist/shared/snapshot/capture-snapshot.js +463 -0
package/dist/shared/snapshot/diff-snapshots.d.ts +72 -0
package/dist/shared/snapshot/diff-snapshots.js +358 -0
package/dist/shared/snapshot/render-snapshot.d.ts +39 -0
package/dist/shared/snapshot/render-snapshot.js +651 -0
package/dist/shared/snapshot/snapshot.spec.d.ts +2 -0
package/dist/shared/snapshot/snapshot.spec.js +333 -0
package/dist/shared/snapshot/types.d.ts +40 -0
package/dist/shared/snapshot/types.js +0 -0
package/dist/shared/snapshot/wait-for-page-stable.d.ts +17 -0
package/dist/shared/snapshot/wait-for-page-stable.js +281 -0
package/dist/shared/state/session-state.d.ts +1 -0
package/dist/shared/state/session-state.js +1 -0
package/docs/experiments.md +67 -0
package/package.json +4 -2
package/skills/libretto/SKILL.md +3 -1
package/skills/libretto-readonly/SKILL.md +1 -1
package/src/cli/AGENTS.md +7 -0
package/src/cli/cli.ts +4 -3
package/src/cli/commands/ai.ts +3 -2
package/src/cli/commands/browser.ts +13 -11
package/src/cli/commands/execution.ts +303 -271
package/src/cli/commands/experiments.ts +120 -0
package/src/cli/commands/setup.ts +18 -36
package/src/cli/commands/shared.ts +20 -0
package/src/cli/commands/snapshot.ts +99 -11
package/src/cli/commands/status.ts +5 -4
package/src/cli/core/ai-model.ts +6 -3
package/src/cli/core/browser.ts +369 -147
package/src/cli/core/config.ts +3 -1
package/src/cli/core/context.ts +4 -0
package/src/cli/core/daemon/config.ts +35 -19
package/src/cli/core/daemon/daemon.ts +686 -106
package/src/cli/core/daemon/ipc.ts +330 -214
package/src/cli/core/daemon/snapshot.ts +106 -8
package/src/cli/core/experiments.ts +85 -0
package/src/cli/core/session.ts +5 -4
package/src/cli/core/skill-version.ts +2 -1
package/src/cli/core/snapshot-analyzer.ts +4 -3
package/src/cli/core/workflow-runner/runner.ts +237 -0
package/src/cli/core/workflow-runtime.ts +85 -0
package/src/cli/router.ts +4 -1
package/src/shared/debug/pause-handler.ts +20 -0
package/src/shared/debug/pause.ts +14 -48
package/src/shared/ipc/AGENTS.md +24 -0
package/src/shared/ipc/child-process-transport.spec.ts +86 -0
package/src/shared/ipc/child-process-transport.ts +96 -0
package/src/shared/ipc/ipc.spec.ts +161 -0
package/src/shared/ipc/ipc.ts +288 -0
package/src/shared/ipc/socket-transport.spec.ts +141 -0
package/src/shared/ipc/socket-transport.ts +189 -0
package/src/shared/package-manager.ts +76 -0
package/src/shared/paths/paths.ts +0 -72
package/src/shared/snapshot/capture-snapshot.ts +615 -0
package/src/shared/snapshot/diff-snapshots.ts +579 -0
package/src/shared/snapshot/render-snapshot.ts +962 -0
package/src/shared/snapshot/snapshot.spec.ts +388 -0
package/src/shared/snapshot/types.ts +43 -0
package/src/shared/snapshot/wait-for-page-stable.ts +425 -0
package/src/shared/state/session-state.ts +1 -0
package/dist/cli/core/daemon/index.js +0 -16
package/dist/cli/core/daemon/spawn.js +0 -90
package/dist/cli/core/pause-signals.js +0 -29
package/dist/cli/workers/run-integration-runtime.js +0 -235
package/dist/cli/workers/run-integration-worker-protocol.js +0 -17
package/dist/cli/workers/run-integration-worker.js +0 -64
package/src/cli/core/daemon/index.ts +0 -24
package/src/cli/core/daemon/spawn.ts +0 -171
package/src/cli/core/pause-signals.ts +0 -35
package/src/cli/workers/run-integration-runtime.ts +0 -326
package/src/cli/workers/run-integration-worker-protocol.ts +0 -19
package/src/cli/workers/run-integration-worker.ts +0 -72

package/dist/shared/snapshot/snapshot.spec.js ADDED Viewed

@@ -0,0 +1,333 @@
+import { chromium } from "playwright";
+import outdent from "outdent";
+import { describe, expect, test as base } from "vitest";
+import { snapshot } from "./capture-snapshot.js";
+import {
+  diffSnapshots,
+  renderSnapshotDiff
+} from "./diff-snapshots.js";
+import { renderSnapshot } from "./render-snapshot.js";
+const test = base.extend({
+  page: async ({}, use) => {
+    const browser = await chromium.launch({ headless: true });
+    const page = await browser.newPage();
+    await use(page);
+    await page.close();
+    await browser.close();
+  },
+  expectSnapshot: async ({ page }, use) => {
+    await use(async (html, expected) => {
+      await page.setContent(outdent.string(html));
+      const raw = await snapshot(page);
+      expect(normalizeIncidentalUrls(renderSnapshot(raw))).toBe(
+        outdent.string(expected)
+      );
+    });
+  },
+  expectScopedSnapshot: async ({ page }, use) => {
+    await use(async (html, refId, expected) => {
+      await page.setContent(outdent.string(html));
+      const raw = await snapshot(page);
+      expect(normalizeIncidentalUrls(renderSnapshot(raw, refId))).toBe(
+        outdent.string(expected)
+      );
+    });
+  },
+  expectSnapshotDiff: async ({ page }, use) => {
+    await use(async (beforeHtml, afterHtml, expected) => {
+      await page.setContent(outdent.string(beforeHtml));
+      const before = await snapshot(page);
+      await page.setContent(outdent.string(afterHtml));
+      const after = await snapshot(page);
+      expect(
+        normalizeIncidentalUrls(
+          renderSnapshotDiff(diffSnapshots(before, after))
+        )
+      ).toBe(outdent.string(expected));
+    });
+  }
+});
+function normalizeIncidentalUrls(rendered) {
+  return rendered.replaceAll(/url="[^"]*"/g, `url="<page-url>"`);
+}
+function makeNode(input) {
+  const node = {
+    nodeId: input.nodeId,
+    ignored: input.ignored ?? false,
+    role: input.role,
+    name: input.name ?? null,
+    value: input.value ?? null,
+    description: input.description ?? null,
+    properties: input.properties ?? {},
+    attributes: input.attributes ?? {},
+    children: input.children ?? [],
+    ref: input.ref ?? null,
+    subtreeSize: 1
+  };
+  node.subtreeSize = countSubtree(node);
+  return node;
+}
+function countSubtree(node) {
+  return 1 + node.children.reduce((sum, child) => sum + countSubtree(child), 0);
+}
+function makeSnapshot(roots, options = {}) {
+  const url = options.url ?? "about:blank";
+  return {
+    title: options.title ?? "Demo Page",
+    url,
+    frames: [
+      {
+        status: "ok",
+        id: "main",
+        index: 0,
+        url,
+        name: null,
+        parentId: null,
+        roots
+      }
+    ]
+  };
+}
+describe("renderSnapshot", () => {
+  test("renders page, frame, semantic roles, heading text, refs, and no command hint", async ({
+    expectSnapshot
+  }) => {
+    await expectSnapshot(
+      `
+      <!doctype html>
+      <html>
+        <head><title>Product Docs</title></head>
+        <body>
+          <header>
+            <nav aria-label="Primary">
+              <a href="/docs">Docs</a>
+            </nav>
+          </header>
+          <main>
+            <h1>Welcome</h1>
+            <button>Save</button>
+            <input placeholder="Search docs" value="query" />
+          </main>
+        </body>
+      </html>
+    `,
+      `
+      <page title="Product Docs" url="<page-url>">
+      	<frame index="0" url="<page-url>">
+      		<document ref="l1">
+      			Product Docs
+      			<banner ref="l2">
+      				...
+      				Primary
+      				<link ref="l4" href="/docs">Docs</link>
+      			</banner>
+      			<main ref="l5">
+      				# Welcome
+      				<button ref="l7">Save</button>
+      				<textbox ref="l8" value="query" placeholder="Search docs">
+      					Search docs
+      					query
+      				</textbox>
+      			</main>
+      		</document>
+      	</frame>
+      </page>
+    `
+    );
+  });
+  test("scopes an already-captured tree by ref with numeric-suffix fallback", async ({
+    expectScopedSnapshot
+  }) => {
+    await expectScopedSnapshot(
+      `
+      <!doctype html>
+      <title>Scoped Snapshot</title>
+      <main>
+        <button>Sibling</button>
+        <button>Target</button>
+      </main>
+    `,
+      "e4",
+      `
+      <page title="Scoped Snapshot" url="<page-url>">
+      	<frame index="0" url="<page-url>">
+      		<button ref="l4">Target</button>
+      	</frame>
+      </page>
+    `
+    );
+  });
+  test("compacts low-value wrappers, clickable generics, single-child chains, and long child lists", async ({
+    expectSnapshot
+  }) => {
+    await expectSnapshot(
+      `
+      <!doctype html>
+      <title>Compact Demo</title>
+      <style>.card { cursor: pointer; }</style>
+      <main>
+        <div><section><p>Flattened wrapper text</p></section></div>
+        <div class="card" onclick="void 0">Open card</div>
+        <main aria-label="Outer">
+          <nav aria-label="Navigation">
+            <form aria-label="Lookup"><button>Submit chain</button></form>
+          </nav>
+        </main>
+        <ul>
+          <li><button>One</button></li>
+          <li><button>Two</button></li>
+          <li><button>Three</button></li>
+          <li><button>Four</button></li>
+          <li><button>Five</button></li>
+          <li><button>Six</button></li>
+        </ul>
+      </main>
+    `,
+      `
+      <page title="Compact Demo" url="<page-url>">
+      	<frame index="0" url="<page-url>">
+      		<document ref="l1">
+      			Compact Demo
+      			<main ref="l2">
+      				Flattened wrapper text
+      				<button ref="l3">Open card</button>
+      				<main ref="l4">
+      					Outer
+      					...
+      					Lookup
+      					<button ref="l7">Submit chain</button>
+      				</main>
+      				<list>
+      					<listitem>
+      						<button ref="l9">One</button>
+      					</listitem>
+      					<listitem>
+      						<button ref="l11">Two</button>
+      					</listitem>
+      					<listitem>
+      						<button ref="l13">Three</button>
+      					</listitem>
+      					<listitem>
+      						<button ref="l15">Four</button>
+      					</listitem>
+      					[Truncated 2 more elements. Interactive elements: <button ref="l17">Five</button>, <button ref="l19">Six</button>]
+      				</list>
+      			</main>
+      		</document>
+      	</frame>
+      </page>
+    `
+    );
+  });
+});
+describe("diffSnapshots", () => {
+  test("returns no rendered diff for unchanged browser-rendered snapshots", async ({
+    expectSnapshotDiff
+  }) => {
+    const html = `
+      <!-- BEFORE -->
+      <!doctype html>
+      <title>Stable Demo</title>
+      <main><button>Stable</button></main>
+    `;
+    await expectSnapshotDiff(html, html, "");
+  });
+  test("tracks added, removed, and modified nodes under context ancestors", async ({
+    expectSnapshotDiff
+  }) => {
+    await expectSnapshotDiff(
+      `
+        <!-- BEFORE -->
+        <!doctype html>
+        <title>Diff Demo</title>
+        <main>
+          <h1>Tasks</h1>
+          <button id="stable">Stable</button>
+          <button id="save">Save</button>
+          <button id="delete">Delete</button>
+        </main>
+      `,
+      `
+        <!-- AFTER -->
+        <!doctype html>
+        <title>Diff Demo</title>
+        <main>
+          <h1>Tasks</h1>
+          <button id="stable">Stable</button>
+          <button id="save">Saved</button>
+          <a id="docs" href="https://example.test/docs">Docs</a>
+        </main>
+      `,
+      `
+      <page title="Diff Demo" url="<page-url>">
+      	<frame index="0" url="<page-url>">
+      		<document ref="l1">
+      			...
+      			<main ref="l2">
+      				...
+      ~ 				<button ref="l5">Saved</button>
+      + 				<link ref="l6" href="https://example.test/docs">Docs</link>
+      - 				<button ref="l6">...</button>
+      			</main>
+      		</document>
+      	</frame>
+      </page>
+    `
+    );
+  });
+  test("suppresses href query and hash changes from browser-rendered links", async ({
+    expectSnapshotDiff
+  }) => {
+    await expectSnapshotDiff(
+      `
+        <!-- BEFORE -->
+        <!doctype html>
+        <title>Href Demo</title>
+        <main><a id="docs" href="https://example.test/docs?utm=old#intro">Docs</a></main>
+      `,
+      `
+        <!-- AFTER -->
+        <!doctype html>
+        <title>Href Demo</title>
+        <main><a id="docs" href="https://example.test/docs?utm=new#api">Docs</a></main>
+      `,
+      ""
+    );
+  });
+  test("suppresses ref-only changes that browser HTML cannot express directly", () => {
+    const before = makeSnapshot([
+      makeNode({
+        nodeId: "root",
+        role: "RootWebArea",
+        ref: "l1",
+        children: [
+          makeNode({
+            nodeId: "docs",
+            role: "link",
+            name: "Docs",
+            ref: "l2",
+            attributes: { href: "https://example.test/docs" }
+          })
+        ]
+      })
+    ]);
+    const after = makeSnapshot([
+      makeNode({
+        nodeId: "root",
+        role: "RootWebArea",
+        ref: "l10",
+        children: [
+          makeNode({
+            nodeId: "docs",
+            role: "link",
+            name: "Docs",
+            ref: "l20",
+            attributes: { href: "https://example.test/docs" }
+          })
+        ]
+      })
+    ]);
+    const diff = diffSnapshots(before, after);
+    expect(renderSnapshotDiff(diff)).toBe("");
+  });
+});

package/dist/shared/snapshot/types.d.ts ADDED Viewed

@@ -0,0 +1,40 @@
+type SnapshotPrimitive = string | number | boolean | null;
+type Snapshot = {
+    title: string;
+    url: string;
+    frames: SnapshotFrame[];
+};
+type SnapshotFrame = SnapshotAvailableFrame | SnapshotUnavailableFrame;
+type SnapshotAvailableFrame = {
+    status: "ok";
+    id: string;
+    index: number;
+    url: string;
+    name: string | null;
+    parentId: string | null;
+    roots: SnapshotNode[];
+};
+type SnapshotUnavailableFrame = {
+    status: "unavailable";
+    id: string;
+    index: number;
+    url: string;
+    name: string | null;
+    parentId: string | null;
+    error: string;
+};
+type SnapshotNode = {
+    nodeId: string;
+    ignored: boolean;
+    role: string;
+    name: string | null;
+    value: SnapshotPrimitive;
+    description: string | null;
+    properties: Record<string, SnapshotPrimitive>;
+    attributes: Record<string, string>;
+    children: SnapshotNode[];
+    ref: string | null;
+    subtreeSize: number;
+};
+export type { Snapshot, SnapshotAvailableFrame, SnapshotFrame, SnapshotNode, SnapshotPrimitive, SnapshotUnavailableFrame };

package/dist/shared/snapshot/types.js ADDED Viewed

File without changes

package/dist/shared/snapshot/wait-for-page-stable.d.ts ADDED Viewed

@@ -0,0 +1,17 @@
+import { Page } from 'playwright';
+type PageStabilityWaitOptions = {
+    timeoutMs?: number;
+    mutationIdleMs?: number;
+    minimumWaitMs?: number;
+    pollIntervalMs?: number;
+};
+type PageStabilityWaitResult = {
+    ok: boolean;
+    diagnostics: string[];
+};
+declare function preparePageStabilityWait(page: Page, options?: Pick<PageStabilityWaitOptions, "timeoutMs">): Promise<PageStabilityWaitResult>;
+declare function waitForPageStable(page: Page, options?: PageStabilityWaitOptions): Promise<PageStabilityWaitResult>;
+declare function installPageStabilityWaiter(): void;
+export { type PageStabilityWaitOptions, type PageStabilityWaitResult, installPageStabilityWaiter, preparePageStabilityWait, waitForPageStable };

package/dist/shared/snapshot/wait-for-page-stable.js ADDED Viewed

@@ -0,0 +1,281 @@
+const DEFAULT_TIMEOUT_MS = 1e4;
+const DEFAULT_MUTATION_IDLE_MS = 400;
+const DEFAULT_MINIMUM_WAIT_MS = 800;
+const DEFAULT_POLL_INTERVAL_MS = 100;
+async function preparePageStabilityWait(page, options = {}) {
+  const diagnostic = await installBrowserStabilityWaiterOnPage(
+    page,
+    options.timeoutMs ?? DEFAULT_TIMEOUT_MS
+  );
+  return {
+    ok: diagnostic === null,
+    diagnostics: diagnostic === null ? [] : [diagnostic]
+  };
+}
+async function waitForPageStable(page, options = {}) {
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const mutationIdleMs = options.mutationIdleMs ?? DEFAULT_MUTATION_IDLE_MS;
+  const minimumWaitMs = options.minimumWaitMs ?? DEFAULT_MINIMUM_WAIT_MS;
+  const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+  const deadline = Date.now() + timeoutMs;
+  const loadDiagnostics = await Promise.all([
+    waitForLoadState(page, "domcontentloaded", deadline),
+    waitForLoadState(page, "load", deadline)
+  ]);
+  const browserDiagnostic = await waitForBrowserStability(page, {
+    timeoutMs: Math.max(0, deadline - Date.now()),
+    mutationIdleMs,
+    minimumWaitMs,
+    pollIntervalMs
+  });
+  const diagnostics = [...loadDiagnostics, browserDiagnostic].filter(
+    (diagnostic) => diagnostic !== null
+  );
+  return { ok: diagnostics.length === 0, diagnostics };
+}
+async function waitForLoadState(page, state, deadline) {
+  const timeout = Math.max(0, deadline - Date.now());
+  if (timeout === 0) return `Timed out waiting for ${state}`;
+  try {
+    await page.waitForLoadState(state, { timeout });
+    return null;
+  } catch (error) {
+    return `Failed to wait for ${state}: ${errorMessage(error)}`;
+  }
+}
+async function waitForBrowserStability(page, args) {
+  const deadline = Date.now() + args.timeoutMs;
+  let lastError = null;
+  while (Date.now() < deadline) {
+    const installDiagnostic = await installBrowserStabilityWaiterOnPage(
+      page,
+      Math.max(0, deadline - Date.now())
+    );
+    if (installDiagnostic) return installDiagnostic;
+    try {
+      return await page.evaluate(runBrowserStabilityWait, {
+        ...args,
+        timeoutMs: Math.max(0, deadline - Date.now())
+      });
+    } catch (error) {
+      lastError = errorMessage(error);
+      if (!isRetryableExecutionContextError(lastError)) {
+        return `Failed to wait for page stability: ${lastError}`;
+      }
+      await sleep(Math.min(100, Math.max(0, deadline - Date.now())));
+    }
+  }
+  return lastError ? `Failed to wait for page stability: ${lastError}` : "Timed out waiting for page stability";
+}
+async function installBrowserStabilityWaiterOnPage(page, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  let lastError = null;
+  while (Date.now() < deadline) {
+    try {
+      await page.evaluate(installPageStabilityWaiter);
+      return null;
+    } catch (error) {
+      lastError = errorMessage(error);
+      if (!isRetryableExecutionContextError(lastError)) {
+        return `Failed to install page stability waiter: ${lastError}`;
+      }
+      await sleep(Math.min(100, Math.max(0, deadline - Date.now())));
+    }
+  }
+  return lastError ? `Failed to install page stability waiter: ${lastError}` : "Timed out installing page stability waiter";
+}
+function installPageStabilityWaiter() {
+  const symbol = /* @__PURE__ */ Symbol.for("libretto.pageStabilityWaiter");
+  const windowWithWaiter = window;
+  if (windowWithWaiter[symbol]) return;
+  const state = {
+    pendingRequests: 0,
+    pendingUrls: /* @__PURE__ */ new Set()
+  };
+  const requestStarted = (url) => {
+    state.pendingRequests += 1;
+    state.pendingUrls.add(url);
+  };
+  const requestFinished = (url) => {
+    state.pendingRequests = Math.max(0, state.pendingRequests - 1);
+    state.pendingUrls.delete(url);
+  };
+  const originalFetch = window.fetch;
+  if (typeof originalFetch === "function") {
+    window.fetch = function trackedFetch(input, init) {
+      const url = requestUrl(input);
+      requestStarted(url);
+      return originalFetch.call(this, input, init).finally(() => {
+        requestFinished(url);
+      });
+    };
+  }
+  const originalOpen = XMLHttpRequest.prototype.open;
+  const originalSend = XMLHttpRequest.prototype.send;
+  const requestUrls = /* @__PURE__ */ new WeakMap();
+  const startedRequests = /* @__PURE__ */ new WeakSet();
+  XMLHttpRequest.prototype.open = function trackedOpen(method, url, async, username, password) {
+    requestUrls.set(this, String(url));
+    return originalOpen.call(
+      this,
+      method,
+      url,
+      async ?? true,
+      username,
+      password
+    );
+  };
+  XMLHttpRequest.prototype.send = function trackedSend(body) {
+    const url = requestUrls.get(this) ?? "XMLHttpRequest";
+    requestStarted(url);
+    startedRequests.add(this);
+    const finish = () => {
+      if (!startedRequests.has(this)) return;
+      startedRequests.delete(this);
+      requestFinished(url);
+    };
+    this.addEventListener("loadend", finish, { once: true });
+    try {
+      return originalSend.call(this, body);
+    } catch (error) {
+      finish();
+      throw error;
+    }
+  };
+  const waitForStability = async (args) => {
+    const sleepInPage = (ms) => new Promise((resolve) => window.setTimeout(resolve, ms));
+    const startedAt = Date.now();
+    let lastActivityAt = Date.now();
+    let lastResources = {
+      pendingResources: 0,
+      pendingResourceLabels: []
+    };
+    let lastPendingRequests = state.pendingRequests;
+    let lastPendingUrls = [...state.pendingUrls];
+    const markActivity = () => {
+      lastActivityAt = Date.now();
+    };
+    const observer = new MutationObserver(markActivity);
+    const root = document.documentElement ?? document.body;
+    if (root) {
+      observer.observe(root, {
+        attributes: true,
+        childList: true,
+        characterData: true,
+        subtree: true
+      });
+    }
+    try {
+      while (Date.now() - startedAt < args.timeoutMs) {
+        lastResources = countPendingResourceElements();
+        lastPendingRequests = state.pendingRequests;
+        lastPendingUrls = [...state.pendingUrls];
+        const pageLoaded = document.readyState === "complete";
+        const mutationIdle = Date.now() - lastActivityAt >= args.mutationIdleMs;
+        const waitedLongEnough = Date.now() - startedAt >= args.minimumWaitMs;
+        const requestIdle = lastPendingRequests === 0;
+        const resourceIdle = lastResources.pendingResources === 0;
+        if (pageLoaded && mutationIdle && waitedLongEnough && requestIdle && resourceIdle) {
+          return null;
+        }
+        await sleepInPage(args.pollIntervalMs);
+      }
+    } finally {
+      observer.disconnect();
+    }
+    return formatStabilityTimeout({
+      timeoutMs: args.timeoutMs,
+      readyState: document.readyState,
+      pendingRequests: lastPendingRequests,
+      pendingUrls: lastPendingUrls,
+      pendingResources: lastResources.pendingResources,
+      pendingResourceLabels: lastResources.pendingResourceLabels
+    });
+  };
+  Object.defineProperty(windowWithWaiter, symbol, {
+    value: { waitForStability },
+    configurable: false,
+    enumerable: false,
+    writable: false
+  });
+  function countPendingResourceElements() {
+    const elements = Array.from(
+      document.querySelectorAll(
+        'img,video,audio,embed,object,iframe[src],link[rel="stylesheet"][href]'
+      )
+    );
+    let pendingResources = 0;
+    const pendingResourceLabels = [];
+    const markPending = (element) => {
+      pendingResources += 1;
+      if (pendingResourceLabels.length < 5) {
+        pendingResourceLabels.push(resourceLabel(element));
+      }
+    };
+    for (const element of elements) {
+      const tagName = element.tagName.toLowerCase();
+      if (tagName === "img") {
+        const image = element;
+        if (image.loading !== "lazy" && !image.complete) markPending(element);
+        continue;
+      }
+      if (tagName === "video" || tagName === "audio") {
+        const media = element;
+        if (media.readyState < HTMLMediaElement.HAVE_CURRENT_DATA) {
+          markPending(element);
+        }
+        continue;
+      }
+      if (tagName === "iframe") {
+        const iframe = element;
+        try {
+          if (iframe.contentDocument && iframe.contentDocument.readyState !== "complete") {
+            markPending(element);
+          }
+        } catch {
+        }
+        continue;
+      }
+      if (tagName === "link") {
+        const link = element;
+        if (!link.sheet) markPending(element);
+      }
+    }
+    return { pendingResources, pendingResourceLabels };
+  }
+  function requestUrl(input) {
+    if (typeof input === "string") return input;
+    if (input instanceof URL) return input.href;
+    return input.url;
+  }
+  function resourceLabel(element) {
+    const tagName = element.tagName.toLowerCase();
+    const source = element.getAttribute("src") ?? element.getAttribute("href") ?? "";
+    return source ? `${tagName}:${source}` : tagName;
+  }
+  function formatStabilityTimeout(args) {
+    const urls = args.pendingUrls.slice(0, 5).join(", ");
+    const resources = args.pendingResourceLabels.join(", ");
+    return `Timed out waiting for page stability after ${args.timeoutMs}ms (readyState=${args.readyState}, pendingRequests=${args.pendingRequests}${urls ? `, pendingUrls=${urls}` : ""}, pendingResources=${args.pendingResources}${resources ? `, pendingResourceLabels=${resources}` : ""})`;
+  }
+}
+async function runBrowserStabilityWait(args) {
+  const symbol = /* @__PURE__ */ Symbol.for("libretto.pageStabilityWaiter");
+  const waiter = window[symbol];
+  if (!waiter) return "Page stability waiter was not installed.";
+  return waiter.waitForStability(args);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isRetryableExecutionContextError(message) {
+  return message.includes("Execution context was destroyed") || message.includes("Cannot find context with specified id") || message.includes("Most likely the page has been closed");
+}
+export {
+  installPageStabilityWaiter,
+  preparePageStabilityWait,
+  waitForPageStable
+};

package/dist/shared/state/session-state.d.ts CHANGED Viewed

@@ -44,6 +44,7 @@ declare const SessionStateFileSchema: z.ZodObject<{
         width: z.ZodNumber;
         height: z.ZodNumber;
     }, z.core.$strip>>;
+    stayOpenOnSuccess: z.ZodOptional<z.ZodBoolean>;
     provider: z.ZodOptional<z.ZodObject<{
         name: z.ZodString;
         sessionId: z.ZodString;

package/dist/shared/state/session-state.js CHANGED Viewed

@@ -27,6 +27,7 @@ const SessionStateFileSchema = z.object({
   status: SessionStatusSchema.optional(),
   mode: SessionAccessModeSchema.default("write-access"),
   viewport: SessionViewportSchema.optional(),
+  stayOpenOnSuccess: z.boolean().optional(),
   provider: ProviderStateSchema.optional(),
   daemonSocketPath: z.string().optional()
 });