tapline-host 1.1.0 → 1.2.0

package/dist/tools.d.ts

@@ -178,6 +178,21 @@ export declare const toolShapes: {
         readonly name: z.ZodString;
         readonly update: z.ZodOptional<z.ZodBoolean>;
         readonly width: z.ZodOptional<z.ZodNumber>;
+        readonly threshold: z.ZodOptional<z.ZodNumber>;
+        readonly ignore: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            ref: z.ZodOptional<z.ZodString>;
+            id: z.ZodOptional<z.ZodString>;
+            label: z.ZodOptional<z.ZodString>;
+            text: z.ZodOptional<z.ZodString>;
+            index: z.ZodOptional<z.ZodNumber>;
+            x: z.ZodOptional<z.ZodNumber>;
+            y: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>]>>>;
     };
     readonly filmstrip: {
         readonly frames: z.ZodOptional<z.ZodNumber>;
@@ -241,6 +256,9 @@ export declare const toolShapes: {
                 label: z.ZodOptional<z.ZodString>;
                 gone: z.ZodOptional<z.ZodBoolean>;
                 value: z.ZodOptional<z.ZodString>;
+                matches: z.ZodOptional<z.ZodString>;
+                threshold: z.ZodOptional<z.ZodNumber>;
+                ignore: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
                 timeout: z.ZodOptional<z.ZodNumber>;
             }, z.core.$strip>>;
         }, z.core.$loose>>;
@@ -360,6 +378,15 @@ export declare class TaplineTools {
     private personNotePending;
     private recording;
     private replaying;
+    /**
+     * While a script replays (AGENT-TOOLS 1.9 §14.3): the references folder next to it (looked in first), where a
+     * failed check puts its red picture, and whether the checks save instead of compare (`--update-references`).
+     */
+    private replayContext;
+    /** Where the latest failed check of the running batch saved its picture. */
+    private diffSaved;
+    /** The elements the latest comparison painted its ignore list from: a recording saves its mask from the same list. */
+    private lastMaskElements;
     /** The screen size in points from the latest list or overlay, for the live viewer's 0..1 positions. */
     private lastScreen;
     private shotCount;
@@ -389,6 +416,7 @@ export declare class TaplineTools {
     private currentRoute;
     /** Null when the expectation holds within its time; else how it failed. */
     private expectMissed;
+    private textExpectMissed;
     inspect(args: Shape<"inspect">): Promise<CallToolResult>;
     audit(args?: Shape<"audit">): Promise<CallToolResult>;
     checkLayout(_args?: Shape<"check_layout">): Promise<CallToolResult>;
@@ -430,12 +458,52 @@ export declare class TaplineTools {
     private takeShot;
     /** Adds an image to a result: inline, or saved with its path in file mode. */
     private deliver;
+    /** Where this app's reference pictures are kept, or an error answer. */
+    private referenceFolder;
+    /** The element list for naming regions and masking, read as a peek: the agent's refs and baseline must stay as they are. */
+    private peekElements;
+    /**
+     * Takes the screen and compares it with the saved reference called `name`, never saving. `referencesDirs` are the
+     * folders to look in, in order. A missing reference hands back the screenshot, so the caller may save it.
+     */
+    private checkAgainstReference;
+    /** Why a check does not hold (for `run`, as a step or as `matches`), or null when it matches. */
+    private referenceReason;
+    /** Whether the screen matches the reference `name` now (`expect.matches`): null when it does, else the reason. */
+    private matchMissed;
+    /** Where a check looks for `<name>.jpg`: the folder next to a replayed script first, then the app's own store. */
+    private referencesDirs;
+    /** In a replay, a failed check leaves its red picture at `<script>.diff/<name>.jpg`. */
+    private keepDiff;
+    /** Takes the screen and saves it as the reference `name` in `dir`. */
+    private saveReferenceHere;
+    private writeReference;
+    /** A `compare_screen` step of `run`: it never saves; it holds on a match and stops the batch otherwise. */
+    private compareStep;
+    /**
+     * Saves a visual check that held as a `compareScreen` step of the recording, when one is running: the name, and the
+     * threshold, the ignore list (refs made stable) and the width when given. `update` is never written. Answers an
+     * error line when an ignore ref can't be kept in a script, else null (also when nothing is recording).
+     */
+    private recordCompare;
+    /**
+     * `ignore` as a script keeps it (AGENT-TOOLS 1.9 §14.2): a ref becomes the element's id, else label, else text,
+     * read from the list now. A string is the error answer when a ref can't be kept.
+     */
+    private stableIgnore;
     compareScreen(args: Shape<"compare_screen">): Promise<CallToolResult>;
+    private compareScreenNow;
     filmstrip(args: Shape<"filmstrip">): Promise<CallToolResult>;
     private scriptPath;
     record(args: Shape<"record">): Promise<CallToolResult>;
+    /** `<script dir>/<script name>.references` and `.diff` for a script file. */
+    private scriptSideFolder;
+    /** Copies each reference the steps use from the app's store next to the script; null when there are none. */
+    private copyReferences;
     private scriptList;
-    replay(args: Shape<"replay">): Promise<CallToolResult>;
+    replay(args: Shape<"replay">, options?: {
+        updateReferences?: boolean;
+    }): Promise<CallToolResult>;
     private withLook;
     /**
      * The element a result carries under `key`, for an answer's first line: without its actions, position or