autokap 1.5.3 → 1.5.5

package/assets/skill/OPCODE-REFERENCE.md

@@ -382,16 +382,23 @@ Capture a screenshot of the viewport or a specific element.
 | `captureId` | string | no | Stable identifier for Studio/dev links. Should match preset page/element id |
 | `captureName` | string | no | Human-readable label shown in Studio |
 | `elementSelector` | string | no | CSS selector for element-level capture (crops to element bounds) |
+| `outscale` | OutscaleConfig | no | Padding around the captured element (only applied with `elementSelector`). Typically set by the user post-generation. Omit by default. |
 
 **Can:** Full-page viewport capture, element-level capture (cropped), LLM verification (detects blank/error/loading/overlay states), alt text generation, favicon extraction.
 **Cannot:** Capture content below the fold in a single shot (use SCROLL first). Capture cross-origin iframe content.
 
 **Tip:** Without `elementSelector`, captures the full viewport. With `elementSelector`, captures only that element's bounding box — useful for component-level screenshots.
 
+**`outscale` shape:** all fields optional. `padding` is uniform (pixels). `paddingTop/Right/Bottom/Left` override per side. `paddingPercent` (0–100) scales with the element. `clampToViewport` (default `true`) prevents the crop from exceeding the document. `backgroundColor` fills any uncovered area.
+
 ```json
 { "kind": "CAPTURE_SCREENSHOT", "captureId": "dashboard-main", "captureName": "Dashboard", "elementSelector": "[data-ak=\"main-content\"]", "postcondition": { "type": "always" } }
 ```
 
+```json
+{ "kind": "CAPTURE_SCREENSHOT", "captureName": "Pricing card", "elementSelector": "[data-ak=\"pricing\"]", "outscale": { "padding": 24 }, "postcondition": { "type": "always" } }
+```
+
 ## BEGIN_CLIP
 
 Start recording a clip. All interactions between BEGIN_CLIP and END_CLIP are recorded.

package/assets/skill/SKILL.md

@@ -163,7 +163,7 @@ interface VariantSpec {
 | `SET_THEME` | no | `theme`, `method`, `storageHints?` | `always` | Use `"$variant"`. Prefer `method: "storage"` |
 | `ASSERT_ROUTE` | no | `urlPattern` | `route_matches` | Validation checkpoint |
 | `ASSERT_SURFACE` | no | `selectors[]`, `matchAll` | `always` | Validation checkpoint |
-| `CAPTURE_SCREENSHOT` | no | `captureId`, `captureName`, `elementSelector?` | `always` | `elementSelector` for element-level crop |
+| `CAPTURE_SCREENSHOT` | no | `captureId`, `captureName`, `elementSelector?`, `outscale?` | `always` | `elementSelector` for element-level crop. `outscale` adds padding around the element (user-edited post-generation; omit by default) |
 | `BEGIN_CLIP` | no | `clipId`, `clipName` | `always` | Start recording |
 | `END_CLIP` | no | `clipId`, `clipName` | `always` | Stop recording. Same `clipId` as BEGIN_CLIP |
 | `CLONE_ELEMENT` | yes | `sourceSelector`, `containerSelector`, `count` | `always` | **Non-blocking.** Duplicate a template element N times |

package/dist/cursor-overlay-script.js

@@ -113,6 +113,14 @@ export function buildCursorOverlayScript(theme = 'minimal') {
       triggerPulse();
     };
 
+    // AUT-80 — Browser-side mousedown timestamp buffer. Real CDP-dispatched
+    // \`mousedown\` events fire here at the exact moment the click happens in
+    // the recorded video (the cursor pulse is purely decorative and fires
+    // slightly later). The runner reads this buffer after each click action
+    // and uses the timestamps for the mouse SFX track so audio = visual
+    // click, even across cursor animation latency and frame quantisation.
+    window.__akClickAt = [];
+
     // Keep DOM event listeners as fallback for real mouse events (headed mode)
     document.addEventListener('mousemove', function(e) {
       setCursorPosition(e.clientX, e.clientY);
@@ -122,6 +130,7 @@ export function buildCursorOverlayScript(theme = 'minimal') {
       setCursorPosition(e.clientX, e.clientY);
       cursor.classList.add('__ak_pressed');
       triggerPulse();
+      window.__akClickAt.push(Date.now());
     }, true);
     window.addEventListener('mouseup', function(e) {
       setCursorPosition(e.clientX, e.clientY);
@@ -130,6 +139,14 @@ export function buildCursorOverlayScript(theme = 'minimal') {
     window.addEventListener('click', function(e) {
       setCursorPosition(e.clientX, e.clientY);
       triggerPulse();
+      // Capture synthetic click() dispatches that bypass mousedown (e.g.
+      // dispatchEvent('click') from JS-dispatch opcode paths). Skip if a
+      // mousedown landed in the last 80 ms so we don't double-count a
+      // regular mouse-driven click.
+      var last = window.__akClickAt[window.__akClickAt.length - 1];
+      if (last == null || (Date.now() - last) > 80) {
+        window.__akClickAt.push(Date.now());
+      }
     }, true);
   }
 

package/dist/execution-schema.d.ts

@@ -29,6 +29,16 @@ export declare const RecoveryPolicySchema: z.ZodObject<{
     allowReload: z.ZodBoolean;
     allowHealer: z.ZodBoolean;
 }, z.core.$strict>;
+export declare const OutscaleConfigSchema: z.ZodObject<{
+    padding: z.ZodOptional<z.ZodNumber>;
+    paddingTop: z.ZodOptional<z.ZodNumber>;
+    paddingRight: z.ZodOptional<z.ZodNumber>;
+    paddingBottom: z.ZodOptional<z.ZodNumber>;
+    paddingLeft: z.ZodOptional<z.ZodNumber>;
+    paddingPercent: z.ZodOptional<z.ZodNumber>;
+    clampToViewport: z.ZodOptional<z.ZodBoolean>;
+    backgroundColor: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
 export declare const ExecutionOpcodeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     url: z.ZodString;
     description: z.ZodString;
@@ -495,6 +505,16 @@ export declare const ExecutionOpcodeSchema: z.ZodDiscriminatedUnion<[z.ZodObject
     captureId: z.ZodOptional<z.ZodString>;
     captureName: z.ZodOptional<z.ZodString>;
     elementSelector: z.ZodOptional<z.ZodString>;
+    outscale: z.ZodOptional<z.ZodObject<{
+        padding: z.ZodOptional<z.ZodNumber>;
+        paddingTop: z.ZodOptional<z.ZodNumber>;
+        paddingRight: z.ZodOptional<z.ZodNumber>;
+        paddingBottom: z.ZodOptional<z.ZodNumber>;
+        paddingLeft: z.ZodOptional<z.ZodNumber>;
+        paddingPercent: z.ZodOptional<z.ZodNumber>;
+        clampToViewport: z.ZodOptional<z.ZodBoolean>;
+        backgroundColor: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
     description: z.ZodString;
     postcondition: z.ZodObject<{
         type: z.ZodEnum<{
@@ -1688,6 +1708,16 @@ export declare const ExecutionProgramSchema: z.ZodObject<{
         captureId: z.ZodOptional<z.ZodString>;
         captureName: z.ZodOptional<z.ZodString>;
         elementSelector: z.ZodOptional<z.ZodString>;
+        outscale: z.ZodOptional<z.ZodObject<{
+            padding: z.ZodOptional<z.ZodNumber>;
+            paddingTop: z.ZodOptional<z.ZodNumber>;
+            paddingRight: z.ZodOptional<z.ZodNumber>;
+            paddingBottom: z.ZodOptional<z.ZodNumber>;
+            paddingLeft: z.ZodOptional<z.ZodNumber>;
+            paddingPercent: z.ZodOptional<z.ZodNumber>;
+            clampToViewport: z.ZodOptional<z.ZodBoolean>;
+            backgroundColor: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
         description: z.ZodString;
         postcondition: z.ZodObject<{
             type: z.ZodEnum<{
@@ -2665,6 +2695,16 @@ export declare const HealerPatchSchema: z.ZodObject<{
         captureId: z.ZodOptional<z.ZodString>;
         captureName: z.ZodOptional<z.ZodString>;
         elementSelector: z.ZodOptional<z.ZodString>;
+        outscale: z.ZodOptional<z.ZodObject<{
+            padding: z.ZodOptional<z.ZodNumber>;
+            paddingTop: z.ZodOptional<z.ZodNumber>;
+            paddingRight: z.ZodOptional<z.ZodNumber>;
+            paddingBottom: z.ZodOptional<z.ZodNumber>;
+            paddingLeft: z.ZodOptional<z.ZodNumber>;
+            paddingPercent: z.ZodOptional<z.ZodNumber>;
+            clampToViewport: z.ZodOptional<z.ZodBoolean>;
+            backgroundColor: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
         description: z.ZodString;
         postcondition: z.ZodObject<{
             type: z.ZodEnum<{
@@ -3588,6 +3628,16 @@ export declare const HealerPatchSchema: z.ZodObject<{
         captureId: z.ZodOptional<z.ZodString>;
         captureName: z.ZodOptional<z.ZodString>;
         elementSelector: z.ZodOptional<z.ZodString>;
+        outscale: z.ZodOptional<z.ZodObject<{
+            padding: z.ZodOptional<z.ZodNumber>;
+            paddingTop: z.ZodOptional<z.ZodNumber>;
+            paddingRight: z.ZodOptional<z.ZodNumber>;
+            paddingBottom: z.ZodOptional<z.ZodNumber>;
+            paddingLeft: z.ZodOptional<z.ZodNumber>;
+            paddingPercent: z.ZodOptional<z.ZodNumber>;
+            clampToViewport: z.ZodOptional<z.ZodBoolean>;
+            backgroundColor: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
         description: z.ZodString;
         postcondition: z.ZodObject<{
             type: z.ZodEnum<{
@@ -4610,6 +4660,16 @@ export declare function safeParseProgramResult(data: unknown): z.ZodSafeParseRes
         captureId?: string | undefined;
         captureName?: string | undefined;
         elementSelector?: string | undefined;
+        outscale?: {
+            padding?: number | undefined;
+            paddingTop?: number | undefined;
+            paddingRight?: number | undefined;
+            paddingBottom?: number | undefined;
+            paddingLeft?: number | undefined;
+            paddingPercent?: number | undefined;
+            clampToViewport?: boolean | undefined;
+            backgroundColor?: string | undefined;
+        } | undefined;
         stepId?: string | undefined;
     } | {
         description: string;

package/dist/execution-schema.js

@@ -242,12 +242,23 @@ const ScrollOpcodeSchema = z.object({
     targetSelector: z.string().optional(),
     target: SemanticTargetSchema.optional(),
 }).strict();
+export const OutscaleConfigSchema = z.object({
+    padding: z.number().min(0).optional(),
+    paddingTop: z.number().min(0).optional(),
+    paddingRight: z.number().min(0).optional(),
+    paddingBottom: z.number().min(0).optional(),
+    paddingLeft: z.number().min(0).optional(),
+    paddingPercent: z.number().min(0).max(100).optional(),
+    clampToViewport: z.boolean().optional(),
+    backgroundColor: z.string().optional(),
+}).strict();
 const CaptureScreenshotOpcodeSchema = z.object({
     kind: z.literal('CAPTURE_SCREENSHOT'),
     ...opcodeBase,
     captureId: z.string().optional(),
     captureName: z.string().optional(),
     elementSelector: z.string().optional(),
+    outscale: OutscaleConfigSchema.optional(),
 }).strict();
 const BeginClipOpcodeSchema = z.object({
     kind: z.literal('BEGIN_CLIP'),

package/dist/execution-types.d.ts

@@ -4,7 +4,7 @@
  * All types for the compiled execution model:
  * preset (natural language) -> ExecutionProgram (typed IR) -> deterministic runtime
  */
-import type { AKTree, BrowserStorageState, BrowserSessionStorageState, VideoCursorTheme, VideoPageSignals } from './types.js';
+import type { AKTree, BrowserStorageState, BrowserSessionStorageState, OutscaleConfig, VideoCursorTheme, VideoPageSignals } from './types.js';
 import type { MockupOptions } from './mockup.js';
 /** Sentinel value that resolves to the current variant's locale or theme at runtime */
 export declare const VARIANT_PLACEHOLDER: "$variant";
@@ -247,6 +247,8 @@ export interface CaptureScreenshotOpcode extends OpcodeBase {
     captureName?: string;
     /** Optional element selector for element-level capture */
     elementSelector?: string;
+    /** Optional padding around the captured element. Only applied when `elementSelector` is set. */
+    outscale?: OutscaleConfig;
 }
 export interface BeginClipOpcode extends OpcodeBase {
     kind: 'BEGIN_CLIP';
@@ -809,7 +811,7 @@ export interface RuntimeAdapter {
         method: string | null;
     }>;
     takeScreenshot(): Promise<Buffer>;
-    takeElementScreenshot?(selector: string): Promise<Buffer>;
+    takeElementScreenshot?(selector: string, outscale?: OutscaleConfig): Promise<Buffer>;
     takeCleanScreenshot(): Promise<Buffer>;
     beginRecording(options: RecordingOptions): Promise<void>;
     endRecording(): Promise<RecordingResult>;

package/dist/opcode-runner.js

@@ -545,7 +545,7 @@ async function executeOpcodeAction(opcode, opcodeIndex, adapter, artifacts, tele
                 const captureUrl = await adapter.getCurrentUrl();
                 const takeBuffer = async () => {
                     if (opcode.elementSelector && adapter.takeElementScreenshot) {
-                        return adapter.takeElementScreenshot(opcode.elementSelector);
+                        return adapter.takeElementScreenshot(opcode.elementSelector, opcode.outscale);
                     }
                     if (opcode.elementSelector) {
                         throw new Error(`element capture requires adapter support for selector "${opcode.elementSelector}"`);

package/dist/program-signing.d.ts

@@ -608,6 +608,16 @@ export declare const SignedExecutionProgramEnvelopeSchema: z.ZodObject<{
             captureId: z.ZodOptional<z.ZodString>;
             captureName: z.ZodOptional<z.ZodString>;
             elementSelector: z.ZodOptional<z.ZodString>;
+            outscale: z.ZodOptional<z.ZodObject<{
+                padding: z.ZodOptional<z.ZodNumber>;
+                paddingTop: z.ZodOptional<z.ZodNumber>;
+                paddingRight: z.ZodOptional<z.ZodNumber>;
+                paddingBottom: z.ZodOptional<z.ZodNumber>;
+                paddingLeft: z.ZodOptional<z.ZodNumber>;
+                paddingPercent: z.ZodOptional<z.ZodNumber>;
+                clampToViewport: z.ZodOptional<z.ZodBoolean>;
+                backgroundColor: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
             description: z.ZodString;
             postcondition: z.ZodObject<{
                 type: z.ZodEnum<{

package/dist/video-narration-schema.d.ts

@@ -634,6 +634,16 @@ export declare const VideoIngestPayloadSchema: z.ZodObject<{
             captureId: z.ZodOptional<z.ZodString>;
             captureName: z.ZodOptional<z.ZodString>;
             elementSelector: z.ZodOptional<z.ZodString>;
+            outscale: z.ZodOptional<z.ZodObject<{
+                padding: z.ZodOptional<z.ZodNumber>;
+                paddingTop: z.ZodOptional<z.ZodNumber>;
+                paddingRight: z.ZodOptional<z.ZodNumber>;
+                paddingBottom: z.ZodOptional<z.ZodNumber>;
+                paddingLeft: z.ZodOptional<z.ZodNumber>;
+                paddingPercent: z.ZodOptional<z.ZodNumber>;
+                clampToViewport: z.ZodOptional<z.ZodBoolean>;
+                backgroundColor: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
             description: z.ZodString;
             postcondition: z.ZodObject<{
                 type: z.ZodEnum<{

package/dist/web-playwright-local.d.ts

@@ -5,7 +5,7 @@
  * This is the first (and for now only) RuntimeAdapter implementation.
  */
 import type { Browser } from './browser.js';
-import type { AKTree, VideoPageSignals } from './types.js';
+import type { AKTree, OutscaleConfig, VideoPageSignals } from './types.js';
 import type { RuntimeAdapter, ClickOptions, WaitCondition, RecordingOptions, RecordingResult, SemanticTarget } from './execution-types.js';
 import { type ResolveOptions } from './semantic-resolver.js';
 export declare class WebPlaywrightLocal implements RuntimeAdapter {
@@ -63,7 +63,7 @@ export declare class WebPlaywrightLocal implements RuntimeAdapter {
         method: string | null;
     }>;
     takeScreenshot(): Promise<Buffer>;
-    takeElementScreenshot(selector: string): Promise<Buffer>;
+    takeElementScreenshot(selector: string, outscale?: OutscaleConfig): Promise<Buffer>;
     takeCleanScreenshot(): Promise<Buffer>;
     beginRecording(options: RecordingOptions): Promise<void>;
     getElementBoundingBox(selector: string): Promise<{
@@ -165,4 +165,18 @@ export declare class WebPlaywrightLocal implements RuntimeAdapter {
     private relativeClickPosition;
     private moveClipCursorToPoint;
     private emitClipClickPulse;
+    /**
+     * Drain the browser-side `__akClickAt` buffer for timestamps newer than
+     * `sinceMs`, replay them through `onClick`, and reset the buffer so the
+     * next click action starts fresh. This is what makes mouse SFX line up
+     * exactly with the visual click in the recorded video — the mousedown
+     * listener inside the cursor overlay timestamps each click at the same
+     * instant the browser dispatches it, which is also the frame the CDP
+     * screencast captures.
+     *
+     * Falls back to `sinceMs` (Node wall-clock at action dispatch) when the
+     * buffer is empty (e.g. `useKeyboard` Enter-press path, or transient
+     * page.evaluate failure).
+     */
+    private reportClickSfxTimestamps;
 }

package/dist/web-playwright-local.js

@@ -77,12 +77,12 @@ export class WebPlaywrightLocal {
         const page = await this.browser.currentPage;
         const t0 = Date.now();
         logger.debug(`[click] start selector="${selector}"${options?.useKeyboard ? ' mode=keyboard' : ''}${options?.useJsDispatch ? ' mode=js_dispatch' : ''}${options?.coordinates ? ` mode=coords(${options.coordinates.x},${options.coordinates.y})` : ''}`);
-        const fireClickSfx = () => options?.onClick?.(Date.now());
         try {
             if (options?.coordinates) {
                 await this.moveClipCursorToPoint(options.coordinates);
-                fireClickSfx();
+                const dispatchedAt = Date.now();
                 await this.browser.clickByCoordinates(options.coordinates.x, options.coordinates.y);
+                await this.reportClickSfxTimestamps(page, dispatchedAt, options?.onClick);
                 logger.debug(`[click] done coords took ${Date.now() - t0}ms`);
                 return;
             }
@@ -90,14 +90,17 @@ export class WebPlaywrightLocal {
             const animatedTarget = await this.moveClipCursorToLocator(locator);
             if (options?.useKeyboard) {
                 await locator.focus();
-                fireClickSfx();
+                const dispatchedAt = Date.now();
                 await page.keyboard.press('Enter');
+                // No real mousedown fires on Enter — fall back to Node timing.
+                options?.onClick?.(dispatchedAt);
                 logger.debug(`[click] done keyboard took ${Date.now() - t0}ms`);
                 return;
             }
             if (options?.useJsDispatch) {
-                fireClickSfx();
+                const dispatchedAt = Date.now();
                 await locator.dispatchEvent('click');
+                await this.reportClickSfxTimestamps(page, dispatchedAt, options?.onClick);
                 logger.debug(`[click] done js_dispatch took ${Date.now() - t0}ms`);
                 return;
             }
@@ -107,18 +110,19 @@ export class WebPlaywrightLocal {
                 ? await this.relativeClickPosition(locator, animatedTarget)
                 : null;
             if (options?.button && options.button !== 'left') {
-                fireClickSfx();
+                const dispatchedAt = Date.now();
                 await locator.click({
                     button: options.button,
                     timeout: 5000,
                     force: options?.force,
                     ...(clickPosition ? { position: clickPosition } : {}),
                 });
+                await this.reportClickSfxTimestamps(page, dispatchedAt, options?.onClick);
                 logger.debug(`[click] done button=${options.button} took ${Date.now() - t0}ms`);
                 return;
             }
+            const dispatchedAt = Date.now();
             if (clickPosition) {
-                fireClickSfx();
                 await locator.click({
                     timeout: 5000,
                     force: options?.force,
@@ -126,9 +130,9 @@ export class WebPlaywrightLocal {
                 });
             }
             else {
-                fireClickSfx();
                 await this.browser.clickBySelector(selector, { force: options?.force });
             }
+            await this.reportClickSfxTimestamps(page, dispatchedAt, options?.onClick);
             await this.emitClipClickPulse();
             logger.debug(`[click] done normal took ${Date.now() - t0}ms`);
         }
@@ -151,11 +155,12 @@ export class WebPlaywrightLocal {
         const position = target
             ? await this.relativeClickPosition(resolved.locator, target)
             : null;
-        opts.onClick?.(Date.now());
+        const dispatchedAt = Date.now();
         await resolved.locator.click({
             timeout: 5000,
             ...(position ? { position } : {}),
         });
+        await this.reportClickSfxTimestamps(page, dispatchedAt, opts.onClick);
     }
     /**
      * Type into an element using semantic target resolution.
@@ -311,8 +316,8 @@ export class WebPlaywrightLocal {
     async takeScreenshot() {
         return this.browser.takeScreenshot();
     }
-    async takeElementScreenshot(selector) {
-        const { buffer } = await this.browser.screenshotBySelector(selector);
+    async takeElementScreenshot(selector, outscale) {
+        const { buffer } = await this.browser.screenshotBySelector(selector, outscale);
         return buffer;
     }
     async takeCleanScreenshot() {
@@ -649,13 +654,14 @@ export class WebPlaywrightLocal {
             ? await this.relativeClickPosition(locator, target)
             : null;
         const opts = { timeout: 5000, ...(position ? { position } : {}) };
-        actionOpts?.onClick?.(Date.now());
+        const dispatchedAt = Date.now();
         if (checked) {
             await locator.check(opts);
         }
         else {
             await locator.uncheck(opts);
         }
+        await this.reportClickSfxTimestamps(page, dispatchedAt, actionOpts?.onClick);
     }
     async doubleClick(selector, actionOpts) {
         const page = await this.browser.currentPage;
@@ -664,11 +670,12 @@ export class WebPlaywrightLocal {
         const position = target
             ? await this.relativeClickPosition(locator, target)
             : null;
-        actionOpts?.onClick?.(Date.now());
+        const dispatchedAt = Date.now();
         await locator.dblclick({
             timeout: 5000,
             ...(position ? { position } : {}),
         });
+        await this.reportClickSfxTimestamps(page, dispatchedAt, actionOpts?.onClick);
     }
     async drag(opts) {
         const page = await this.browser.currentPage;
@@ -1021,6 +1028,47 @@ export class WebPlaywrightLocal {
                 window.__akClickPulse(px, py);
         }, { px: Math.round(x), py: Math.round(y) }).catch(() => { });
     }
+    /**
+     * Drain the browser-side `__akClickAt` buffer for timestamps newer than
+     * `sinceMs`, replay them through `onClick`, and reset the buffer so the
+     * next click action starts fresh. This is what makes mouse SFX line up
+     * exactly with the visual click in the recorded video — the mousedown
+     * listener inside the cursor overlay timestamps each click at the same
+     * instant the browser dispatches it, which is also the frame the CDP
+     * screencast captures.
+     *
+     * Falls back to `sinceMs` (Node wall-clock at action dispatch) when the
+     * buffer is empty (e.g. `useKeyboard` Enter-press path, or transient
+     * page.evaluate failure).
+     */
+    async reportClickSfxTimestamps(page, sinceMs, onClick) {
+        if (!onClick)
+            return;
+        let captured = [];
+        try {
+            captured = (await page.evaluate((cutoff) => {
+                const buf = window.__akClickAt;
+                if (!Array.isArray(buf))
+                    return [];
+                const fresh = buf.filter((t) => typeof t === 'number' && t >= cutoff);
+                // Reset the buffer so successive click actions don't see each
+                // others' timestamps. We mutate the array in place to keep the
+                // reference stable for any other consumers (none today).
+                buf.length = 0;
+                return fresh;
+            }, sinceMs));
+        }
+        catch {
+            captured = [];
+        }
+        if (captured.length > 0) {
+            for (const t of captured)
+                onClick(t);
+        }
+        else {
+            onClick(sinceMs);
+        }
+    }
 }
 function describeResolveOptions(opts) {
     const parts = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autokap",
-  "version": "1.5.3",
+  "version": "1.5.5",
   "description": "AI-powered CLI tool for capturing clean screenshots of websites",
   "type": "module",
   "main": "./dist/index.js",