@ai-ecoverse/slicc-browsers 1.7.10 → 1.7.12

package/README.md

@@ -170,7 +170,7 @@ Any `cdp`, `page` or `children` step can take `requires`, the capabilities it ne
   - `eval`: evaluate `expression`.
   `hops` routes `url` through `/hop` on each `origin`, with its `code`.
 - `{ "answer": { "url", "stage"?, "cdp"?, "params"?, "hold"? } }`: answer each paused request or auth challenge for `url` with that call; `hold` leaves it paused. Every other paused request continues unchanged.
-- `{ "children": steps, "where"? }`: run these steps on each target auto-attached from then on, then resume it. `where` scopes them to the row's own target: `{ "openerId": "page" }` (opened by the row's page) or `{ "urlPrefix": url }`; other attached targets are resumed and otherwise left alone.
+- `{ "children": steps, "where"? }`: run these steps on each target auto-attached from then on, then resume it. `where` scopes them to the row's own target: `{ "openerId": "page" }` (opened by the row's page) or `{ "urlPrefix": url }`; other attached targets are resumed and otherwise left alone. When a vector has a `children` step with `where`, a target that attaches before that step runs waits until it does, and is then matched against `where`. A target is only resumed when it attached waiting for the debugger, and a `browser_ui` target (Chrome's own UI, such as `chrome://omnibox-popup.top-chrome/`) is never adopted or sent anything.
 - `{ "settle": { "beacon"?, "served"?, "title"?, "ms"?, "variant"?, "session"?, "dependsOn"?, "or"? } }`: wait for a beacon from `beacon`, for the fixture to log a request for the URL `served`, for the page `title`, or for the session to detach. When a refusal in `dependsOn` was recorded, the beacon can't come: a settle with `or` (a check) then waits until `or` holds, and one without it is skipped. Without such a refusal, `or` plays no part. Each beacon settle after an init script depends on that script's registration, and its `or` is what the row reads: the hops and the destination for the redirect chains, or the served page otherwise. It waits up to `ms` (10000 by default), then another 600 ms. `variant` waits the run's detach variant instead.
 - `{ "wait": ms }`.
 - `{ "paused": { "url", "ms" } }`: wait until the client has seen the pause that an `answer` rule for `url` matches (`Fetch.requestPaused` at the rule's stage, or `Fetch.authRequired` for a `Fetch.continueWithAuth` rule). It waits up to `ms`. On the control leg, a pause that never comes fails the row with `paused: no pause for <url> within <ms>ms`. On the guarded leg the guard may hide that pause, so the step waits the full `ms` and doesn't fail. The C5 guessed-id vectors and `C5.auth` use it before their second request, so the probe's interception id falls between the two ids the guess spans.
@@ -287,6 +287,8 @@ every alternative of an `any`, or a required (`all`, `not` or plain) check, need
 selects one variant or an array; omission selects all. `parallel` defaults to 1.
 With the `browserContexts` capability each leg runs in its own browser context. A `Target.createBrowserContext` that fails with a timeout is retried once, and the row's `notes` records it; any other failure fails the row.
 
+`settleScale` (default 1) multiplies every bound the runner waits on: settles (beacon, served, title and load), `paused`, page and child loads, the wait for a background step's `as` result (`<as> did not complete within <ms>ms`), and the wait for an observation. Adopters on slow hosts can set 3 or 4. Every wait polls and returns as soon as its event arrives, so a larger bound only costs time when something is really missing, and each timeout error names the bound it used. An observation read from the fixture (`observer: "fixture"`, such as a beacon or a served request) that the leg expects to be `true` is polled for up to 5000 ms (scaled) instead of read once. One that the leg expects to be `false` is still read once.
+
 `onStart(row)` receives each row's `id`, `target`, `variant`, `transport` and `via` as the row starts. `run()` returns a promise that also has `inFlight()`, and its result has `inFlight` too. `inFlight()` lists the rows that are running now, each as `{ id, target, variant, leg, phase, step, clients }`, where `step` is the index of the current step in its `phase` (`setup`, `trigger` or `child`), and `clients` lists each client's pending CDP calls as `{ method, session, ageMs }` (`client`, plus `unguarded` when it is a separate client). With `rowTimeoutMs`, a row still running after that many milliseconds fails on its own. Its `errors` hold `row timed out after <ms>ms: <the in-flight view>`, `inFlight` holds the view, and the clients that `clientFactory` made for it are closed. The run then goes on to the next row. It is off by default, and a client passed as `client` is never closed.
 
 `log(row)` receives completed rows. Besides `control`, `guarded`, `live`, `why` and `errors`, a row may carry `ran` (steps that ran on one leg only) and `notes` (settles skipped because their registration was refused). Both are informational: they explain a row's verdict, and adopters (bios, slicc-cli, slicc-cdp) must not count them as failures, or as passes. The verdict is `control`, `guarded` and `live`. A variant supplies the wait before an

package/guard-runner.mjs

@@ -13,6 +13,7 @@ import {
 
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 const namedResultMs = 10000;
+const observeMs = 5000;
 const q = JSON.stringify;
 const at = (value, path = '') =>
   path
@@ -111,6 +112,11 @@ class Execution {
     this.answers = [];
     this.attachSettings = new Map();
     this.childSteps = [];
+    this.deferred = [];
+    this.expectWhere = [...(vector.setup ?? []), ...(vector.trigger ?? [])].some(
+      (step) => step.children && step.where
+    );
+    this.scale = options.settleScale ?? 1;
     this.childRuns = new Map();
     this.named = new Map();
     this.processed = new Set();
@@ -163,8 +169,12 @@ class Execution {
     return out;
   }
 
+  bound(ms) {
+    return Math.round(ms * this.scale);
+  }
+
   async poll(predicate, ms = 1500) {
-    const deadline = Date.now() + ms;
+    const deadline = Date.now() + this.bound(ms);
     do {
       if (await predicate()) return true;
       await sleep(25);
@@ -447,6 +457,11 @@ class Execution {
   adopt(event) {
     const info = event.params.targetInfo;
     const child = event.params.sessionId;
+    if (info?.type === 'browser_ui') return;
+    if (this.expectWhere && !this.childWhere) {
+      this.deferred.push(event);
+      return;
+    }
     if (info?.browserContextId && this.vars.context && info.browserContextId !== this.vars.context)
       return;
     if (this.childWhere && !this.childMatches(info)) {
@@ -462,7 +477,8 @@ class Execution {
       else {
         await this.execute(this.childSteps.slice(0, reload), child);
         const start = this.client.events.length;
-        await outcome(this.client.send('Runtime.runIfWaitingForDebugger', {}, child));
+        if (event.params.waitingForDebugger)
+          await outcome(this.client.send('Runtime.runIfWaitingForDebugger', {}, child));
         await this.poll(
           () =>
             this.client.events
@@ -473,7 +489,8 @@ class Execution {
         await this.execute(this.childSteps.slice(reload), child);
       }
       const resumed = this.client.events.length;
-      await outcome(this.client.send('Runtime.runIfWaitingForDebugger', {}, child));
+      if (event.params.waitingForDebugger)
+        await outcome(this.client.send('Runtime.runIfWaitingForDebugger', {}, child));
       if (this.childSteps.some((step) => step.cdp === 'Page.enable'))
         await this.poll(() => this.firstLoad(child, resumed), 5000);
     })().catch((error) => this.errors.push(String(error.message ?? error)));
@@ -502,7 +519,7 @@ class Execution {
             this.rule(event)?.url === url
         );
     if (!(await this.poll(seen, ms)) && this.side === 'control')
-      this.errors.push(`paused: no pause for ${url} within ${ms}ms`);
+      this.errors.push(`paused: no pause for ${url} within ${this.bound(ms)}ms`);
   }
 
   async answer(event) {
@@ -604,6 +621,7 @@ class Execution {
     if (step.children) {
       this.childSteps = step.children;
       this.childWhere = step.where;
+      for (const event of this.deferred.splice(0)) this.adopt(event);
       return;
     }
     if (step.answer) {
@@ -639,7 +657,7 @@ class Execution {
     if (refused() && !alt) return skipped();
     if (settle.variant) await sleep(this.delay);
     if (settle.title && !this.reader) {
-      await sleep(settle.ms ?? 1500);
+      await sleep(this.bound(settle.ms ?? 1500));
       return;
     }
     const met = await this.poll(async () => {
@@ -665,7 +683,7 @@ class Execution {
     if (refused() && !alt) return skipped();
     if (settle.required && !met)
       this.errors.push(
-        `settle: no ${settle.beacon ? `beacon from ${settle.beacon}` : settle.served ? `request for ${settle.served}` : settle.title ? `title ${settle.title}` : 'load'} within ${settle.ms ?? 1500}ms`
+        `settle: no ${settle.beacon ? `beacon from ${settle.beacon}` : settle.served ? `request for ${settle.served}` : settle.title ? `title ${settle.title}` : 'load'} within ${this.bound(settle.ms ?? 1500)}ms`
       );
   }
 
@@ -783,7 +801,10 @@ class Execution {
     if (!waits.length) return true;
     let timer;
     const expired = new Promise((resolve) => {
-      timer = setTimeout(() => resolve(false), this.options.namedResultMs ?? namedResultMs);
+      timer = setTimeout(
+        () => resolve(false),
+        this.bound(this.options.namedResultMs ?? namedResultMs)
+      );
     });
     const done = await Promise.race([Promise.all(waits).then(() => true), expired]);
     clearTimeout(timer);
@@ -802,11 +823,24 @@ class Execution {
       .filter((name) => typeof name === 'string' && this.named.has(name));
     if (!names.length || (await this.namedSettled(names))) return true;
     this.errors.push(
-      `${names.join(', ')} did not complete within ${this.options.namedResultMs ?? namedResultMs}ms`
+      `${names.join(', ')} did not complete within ${this.bound(this.options.namedResultMs ?? namedResultMs)}ms`
     );
     return false;
   }
 
+  async observe(name, check) {
+    const want = (this.side === 'control' ? this.vector.control.expected : this.vector.expected)?.[
+      name
+    ];
+    if (want !== true || check?.observer !== 'fixture') return this.check(check);
+    let seen = false;
+    await this.poll(async () => {
+      seen = await this.check(check);
+      return seen === true;
+    }, observeMs);
+    return seen;
+  }
+
   async check(check) {
     const c = expand(check, this.vars);
     if (!(await this.ready(c))) return false;
@@ -1010,7 +1044,7 @@ class Execution {
       for (const [name, observation] of Object.entries(this.vector.observe ?? {})) {
         if (!supported(observation.requires, this.options.capabilities)) continue;
         if ((observation.dependsOn ?? []).some((dep) => this.refused[dep])) continue;
-        observed[name] = await this.check(observation.check);
+        observed[name] = await this.observe(name, observation.check);
         if (observation.eitherWhen && this.side === 'guarded')
           observed[`${name}.either`] = await this.check(observation.eitherWhen);
       }
@@ -1379,6 +1413,11 @@ function validateBlocked(vectors) {
 
 function validate(set, opts) {
   if (!opts.fixture?.log) throw new TypeError('fixture.log is required');
+  if (
+    opts.settleScale !== undefined &&
+    !(Number.isFinite(opts.settleScale) && opts.settleScale > 0)
+  )
+    throw new TypeError('settleScale must be a positive number');
   for (const vector of set.vectors)
     for (const [name, observation] of Object.entries(vector.observe ?? {}))
       if (!observation.check) throw new TypeError(`${vector.id}: ${name} lacks a check`);

package/guard-vectors.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "setVersion": "1.7.10",
+  "setVersion": "1.7.12",
   "sources": [
     {
       "repo": "ai-ecoverse/slicc-cli",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-ecoverse/slicc-browsers",
-  "version": "1.7.10",
+  "version": "1.7.12",
   "description": "SLICC's shared browser catalog, JSON schemas and discovery conformance corpus",
   "type": "module",
   "license": "Apache-2.0",