@jitsusama/agentic-harness.core 0.1.0 → 0.3.0

package/dist/web/session.js

@@ -82,9 +82,10 @@ const WAIT_POLL_MS = 100;
 const KNOWN_KEYS = new Set(Object.keys(_keyDefinitions));
 import { readFile } from "node:fs/promises";
 import { createRequire } from "node:module";
-import { buildStructure, enabledRules, foldBehind, foldPair, parseRgb, readAxeRun, TARGET_CAPTURE, visualCaptureSource, } from "./audit/index.js";
-import { inventorySource } from "./design/index.js";
+import { buildStructure, enabledRules, foldBehind, foldPair, MOTION_CAPTURE, parseRgb, readAxeRun, TARGET_CAPTURE, visualCaptureSource, } from "./audit/index.js";
+import { inventorySource, TYPOGRAPHY_CAPTURE, } from "./design/index.js";
 import { describeThrow, evaluationSource, } from "./evaluate/index.js";
+import { HYDRATION_CAPTURE } from "./hydration/index.js";
 import { categoriesFor, compareHeap, foldLayers, foldProfile, foldTrace, LAYER_SETTLE_MS, nameNode, observerBootstrap, readVitalsSource, } from "./perf/index.js";
 import { captureTiles } from "./screenshot.js";
 import { ArtifactLedger } from "./session/artifacts.js";
@@ -1874,6 +1875,39 @@ export class BrowserSession {
         });
         return result.value;
     }
+    /**
+     * What the page keeps doing when asked to hold still.
+     *
+     * Emulates prefers-reduced-motion: reduce, reloads so the page
+     * decides its motion under the preference rather than being
+     * caught mid-flight, reads what is still moving, then puts the
+     * emulation back exactly as it was. The reload matters: a page
+     * picks most of its motion at load, so flipping the preference
+     * on a settled page measures its reaction to a change, not its
+     * behaviour for a visitor who arrived with the preference set.
+     */
+    async motionUnderReduce() {
+        await this.ready();
+        const before = this.emulation.asked;
+        try {
+            await this.emulation.change({ reducedMotion: true });
+            await this.reload();
+            const response = await this.cdp.send("Runtime.evaluate", {
+                expression: MOTION_CAPTURE,
+                returnByValue: true,
+            });
+            if (response.exceptionDetails) {
+                const threw = describeThrow(response.exceptionDetails);
+                throw new Error(`Could not read the motion: ${threw.message}`);
+            }
+            return response.result.value;
+        }
+        finally {
+            // Wholesale, not merged: a merge cannot clear the reduce
+            // this added when the session had no opinion before.
+            await this.emulation.restore(before);
+        }
+    }
     async structure() {
         // Every sibling read waits out a crash recovery first, and
         // this one did not. Promise.all evaluates this.cdp.send when
@@ -1937,6 +1971,45 @@ export class BrowserSession {
         }
         return response.result.value;
     }
+    /**
+     * Both renders of the current page: what the server sends and
+     * what hydration made of it.
+     *
+     * The server render is fetched from inside the page, so it
+     * travels with the session's cookies, and parsed without
+     * running a script. Judging the capture is the hydration
+     * subdomain's job; pair it with logs() so the framework's own
+     * complaints are read beside the comparison.
+     */
+    async hydration() {
+        await this.ready();
+        const response = await this.cdp.send("Runtime.evaluate", {
+            expression: HYDRATION_CAPTURE,
+            awaitPromise: true,
+            returnByValue: true,
+        });
+        if (response.exceptionDetails) {
+            const threw = describeThrow(response.exceptionDetails);
+            throw new Error(`Could not read the renders: ${threw.message}`);
+        }
+        return response.result.value;
+    }
+    /**
+     * How the page's text blocks wrap, measured from real line
+     * boxes rather than estimated from fonts.
+     */
+    async typography() {
+        await this.ready();
+        const response = await this.cdp.send("Runtime.evaluate", {
+            expression: TYPOGRAPHY_CAPTURE,
+            returnByValue: true,
+        });
+        if (response.exceptionDetails) {
+            const threw = describeThrow(response.exceptionDetails);
+            throw new Error(`Could not measure the text: ${threw.message}`);
+        }
+        return response.result.value;
+    }
     async layout() {
         await this.ready();
         const response = await this.cdp.send("Runtime.evaluate", {

package/package.json

@@ -1,12 +1,20 @@
 {
 	"name": "@jitsusama/agentic-harness.core",
-	"version": "0.1.0",
+	"version": "0.3.0",
 	"description": "Pi-agnostic business logic for agentic-harness: state machines, guardian decisions, quest/TDD domain model.",
 	"license": "MIT",
 	"type": "module",
 	"overrides": {
 		"google-auth-library": "$google-auth-library"
 	},
+	"pnpm": {
+		"overrides": {
+			"google-auth-library": "$google-auth-library"
+		},
+		"onlyBuiltDependencies": [
+			"sqlite3"
+		]
+	},
 	"exports": {
 		"./tdd": "./dist/tdd/index.js",
 		"./tdd/presentation": "./dist/tdd/presentation.js",
@@ -73,6 +81,7 @@
 		"./web/environment": "./dist/web/environment/index.js",
 		"./web/environment/devices": "./dist/web/environment/devices.js",
 		"./web/evaluate": "./dist/web/evaluate/index.js",
+		"./web/hydration": "./dist/web/hydration/index.js",
 		"./web/input": "./dist/web/input/index.js",
 		"./web/mermaid": "./dist/web/mermaid.js",
 		"./web/perf": "./dist/web/perf/index.js",
@@ -105,11 +114,11 @@
 	],
 	"scripts": {
 		"build": "tsc -p tsconfig.build.json",
-		"prepare": "npm run build",
+		"prepare": "tsc -p tsconfig.build.json",
 		"lint": "biome check .",
 		"lint:fix": "biome check --write .",
 		"typecheck": "tsc --noEmit",
-		"pretest": "npm run build",
+		"pretest": "tsc -p tsconfig.build.json",
 		"test": "vitest run",
 		"test:watch": "vitest",
 		"test:browser": "vitest run --config vitest.browser.config.ts"

package/dist/memory/db.d.ts

@@ -1,15 +0,0 @@
-/**
- * Thin promise wrapper over the callback-based sqlite3 driver.
- * sqlite3 is a native module, so it is lazy-imported on first
- * open; callers speak promises and never touch the driver
- * directly.
- */
-/** A promise-speaking handle to a SQLite database. */
-export interface Db {
-    run(sql: string, params?: readonly unknown[]): Promise<void>;
-    all<T>(sql: string, params?: readonly unknown[]): Promise<T[]>;
-    exec(sql: string): Promise<void>;
-    close(): Promise<void>;
-}
-/** Open a SQLite database at the given path (`:memory:` for tests). */
-export declare function openDb(dbPath: string): Promise<Db>;

package/dist/memory/db.js

@@ -1,25 +0,0 @@
-/**
- * Thin promise wrapper over the callback-based sqlite3 driver.
- * sqlite3 is a native module, so it is lazy-imported on first
- * open; callers speak promises and never touch the driver
- * directly.
- */
-/** Open a SQLite database at the given path (`:memory:` for tests). */
-export async function openDb(dbPath) {
-    const sqlite3 = await import("sqlite3");
-    const database = new sqlite3.default.Database(dbPath);
-    return {
-        run: (sql, params = []) => new Promise((resolve, reject) => {
-            database.run(sql, params, (err) => (err ? reject(err) : resolve()));
-        }),
-        all: (sql, params = []) => new Promise((resolve, reject) => {
-            database.all(sql, params, (err, rows) => err ? reject(err) : resolve(rows));
-        }),
-        exec: (sql) => new Promise((resolve, reject) => {
-            database.exec(sql, (err) => (err ? reject(err) : resolve()));
-        }),
-        close: () => new Promise((resolve, reject) => {
-            database.close((err) => (err ? reject(err) : resolve()));
-        }),
-    };
-}