agent-afk 5.313.9 → 5.313.10

package/README.md

@@ -61,6 +61,8 @@ Codex imports use `CODEX_HOME` when set (otherwise `~/.codex`) and also discover
 
 ## What it has done
 
+**Constructed SW(27,16), a symmetric weighing matrix the standard archives do not list.** Given a research campaign goal, agent-afk agents picked the target, designed a prescribed-automorphism SAT search, found a symmetric 27x27 weighing matrix in 1903 seconds of solver time, checked it with independent exact checkers on two machines, and ran a kill lane that could not refute it. The standard databases list no symmetric W(27,16). Check it yourself in under a second: [`docs/results/sw-27-16`](docs/results/sw-27-16/README.md).
+
 **Constructed SW(25,16), a math case a 2025 paper listed as open.** Given a one-sentence goal ("settle one published open question"), agent-afk agents picked the target, designed a structured SAT search, found a symmetric 25x25 weighing matrix in 760 seconds of solver time, checked it with independent exact checkers and a prior-work search, and wrote up a short proof. The author of the paper that listed the case as open confirmed it passes his verifier. Check it yourself in under a second: [`docs/results/sw-25-16`](docs/results/sw-25-16/README.md).
 
 ## How it compares

package/dist/browser/playwright/domain-recheck.d.ts

@@ -3,4 +3,10 @@ export interface RecheckablePage {
     url(): string;
     goBack(): Promise<unknown>;
 }
-export declare function recheckLandedUrl(page: RecheckablePage, config: BrowserConfig, clearedUrl: string, invalidateSession: () => Promise<void>): Promise<BlockedByPolicy | null>;
+export interface RecheckOptions {
+    lookupFn?: (hostname: string) => Promise<readonly {
+        address: string;
+    }[]>;
+    allowPrivateHosts?: boolean;
+}
+export declare function recheckLandedUrl(page: RecheckablePage, config: BrowserConfig, clearedUrl: string, invalidateSession: () => Promise<void>, opts?: RecheckOptions): Promise<BlockedByPolicy | null>;

package/dist/browser/playwright/egress-attribution.d.ts

@@ -0,0 +1,18 @@
+import type { Page } from 'playwright';
+import type { BlockedByPolicy } from '../types.js';
+import { EgressBlockedError } from '../../http-client/egress-guard.js';
+import { type EgressRefusal } from './egress-proxy.js';
+import type { RefusalLog } from './egress-launch.js';
+export interface RefusalVerdict {
+    main: EgressRefusal | undefined;
+    any: EgressRefusal | undefined;
+}
+export interface EgressWatch {
+    check(): RefusalVerdict;
+    stop(): RefusalVerdict;
+}
+export declare function watchEgressRefusals(page: Page, log: RefusalLog | undefined): EgressWatch;
+export declare function mainRefusalOutcome(v: RefusalVerdict, url: string): BlockedByPolicy | null;
+export declare function renderRefusalError(v: RefusalVerdict): EgressBlockedError | undefined;
+export declare function invalidateOnRefusal(outcome: BlockedByPolicy, invalidate: () => Promise<void>): Promise<BlockedByPolicy>;
+export declare function runActionWithRetry(execute: () => Promise<void>, consumeTrap: () => unknown, watch: EgressWatch): Promise<unknown>;

package/dist/browser/playwright/egress-gate.d.ts

@@ -0,0 +1,14 @@
+import type { BrowserContext, Page, Response } from 'playwright';
+import type { BlockedByPolicy } from '../types.js';
+export declare function checkNavigationEgress(url: string): Promise<BlockedByPolicy | null>;
+export declare function egressBlockOutcome(err: unknown, url: string): BlockedByPolicy | null;
+export declare function watchMainFrameNavigation(page: Page): () => Response | null;
+export declare function checkRedirectChain(response: Response | null, finalUrl: string, proxied?: boolean): Promise<BlockedByPolicy | null>;
+export declare class RequestGuardTrap {
+    private lastError;
+    install(context: BrowserContext): Promise<void>;
+    clear(): void;
+    consume(): unknown;
+}
+export declare function installRenderRouteGuard(context: BrowserContext, guard: (url: string) => Promise<void>, onRefusal: (err: unknown) => void): Promise<void>;
+export { invalidateOnRefusal, mainRefusalOutcome, renderRefusalError, runActionWithRetry, watchEgressRefusals } from './egress-attribution.js';

package/dist/browser/playwright/egress-launch.d.ts

@@ -0,0 +1,20 @@
+import type { LaunchOptions } from 'playwright';
+import { type EgressProxyDeps, type EgressRefusal } from './egress-proxy.js';
+export declare const EGRESS_LAUNCH_ARGS: readonly string[];
+export declare const EGRESS_PROXY_BYPASS = "<-loopback>";
+export declare function buildLaunchOptions(headless: boolean, proxyPort: number | undefined): LaunchOptions;
+export interface RefusalLog {
+    mark(): number;
+    refusalsSince(mark: number): EgressRefusal[];
+}
+export declare class GuardedEgress implements RefusalLog {
+    private readonly deps;
+    private proxy;
+    private unregister;
+    constructor(deps?: EgressProxyDeps);
+    start(headless: boolean): Promise<LaunchOptions>;
+    isActive(): boolean;
+    mark(): number;
+    refusalsSince(mark: number): EgressRefusal[];
+    stop(): Promise<void>;
+}

package/dist/browser/playwright/egress-proxy.d.ts

@@ -0,0 +1,41 @@
+export interface EgressRefusal {
+    seq: number;
+    at: number;
+    target: string;
+    reason: string;
+}
+export interface EgressProxyDeps {
+    lookupFn?: (hostname: string) => Promise<readonly {
+        address: string;
+    }[]>;
+    isBlocked?: (ip: string, port: number) => boolean;
+    connectTimeoutMs?: number;
+    drainTimeoutMs?: number;
+}
+export declare function targetKey(host: string, port: number | string): string;
+export declare function targetKeyFromUrl(raw: string): string | null;
+export declare class EgressProxy {
+    private readonly server;
+    private readonly sockets;
+    private readonly refusals;
+    private seq;
+    private closing;
+    private readonly lookupFn;
+    private readonly isBlocked;
+    private readonly connectTimeoutMs;
+    private readonly drainTimeoutMs;
+    constructor(deps?: EgressProxyDeps);
+    listen(): Promise<number>;
+    mark(): number;
+    refusalsSince(mark: number): EgressRefusal[];
+    resolve(host: string, port: number): Promise<string[]>;
+    private lookupGuarded;
+    private record;
+    private track;
+    private dial;
+    private openUpstream;
+    private onForward;
+    private relayResponse;
+    private onTunnel;
+    close(): Promise<void>;
+}

package/dist/browser/playwright/launcher.d.ts

@@ -1,5 +1,6 @@
 import type { Browser, BrowserContext, Page } from 'playwright';
 import type { BrowserConfig } from '../types.js';
+import { type RefusalLog } from './egress-launch.js';
 export declare class BrowserLauncher {
     private readonly config;
     private browser;
@@ -7,6 +8,7 @@ export declare class BrowserLauncher {
     private launchPromise;
     private launchFailure;
     private shutdownComplete;
+    private readonly egress;
     constructor(config: BrowserConfig);
     private clearLaunchFailure;
     private latchLaunchFailure;
@@ -15,6 +17,9 @@ export declare class BrowserLauncher {
     ensureContext(sessionId: string): Promise<BrowserContext>;
     ensurePage(sessionId: string): Promise<Page>;
     getPage(sessionId: string): Page | undefined;
+    consumeRequestGuardError(sessionId: string): unknown;
+    egressLog(): RefusalLog | undefined;
+    clearRequestGuardError(sessionId: string): void;
     renderHtml(url: string, opts: {
         timeoutMs: number;
         waitUntil: 'load' | 'domcontentloaded' | 'networkidle';