@broberg/lens-daemon 0.1.31 → 0.1.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@broberg/lens-daemon",
-  "version": "0.1.31",
+  "version": "0.1.34",
   "description": "The Lens module of the cardmem daemon (flows, critic, coverage, capture sessions, the /lens/* routes and the cardmem-lens MCP) as a package. The daemon mounts createLensRouter(deps) + createLensMcpRouter(deps). Bun runtime.",
   "type": "module",
   "license": "MIT",
@@ -12,7 +12,7 @@
     "pixelmatch": "^6.0.0",
     "playwright": "1.61.1",
     "pngjs": "^7.0.0",
-    "sharp": "^0.33.5",
+    "sharp": "^0.35.5",
     "turndown": "^7.2.4",
     "zod": "^3.23.8",
     "@broberg/lens-engine": "0.14.1",

package/src/browser.ts

@@ -10,7 +10,7 @@
 // auth (F074.4) and concurrent captures never bleed into each other. The
 // context + page are always closed in a finally, even on capture error.
 
-import { claimProfile, profileDir } from './profiles.ts';
+import { bindProfileChannel, claimProfile, profileDir, type ProfileChannel } from './profiles.ts';
 import {
   chromium,
   webkit,
@@ -228,6 +228,19 @@ export interface WithPageOptions {
    *  This is a SECOND launch path, not a flag on the warm browser: extensions
    *  need launchPersistentContext with a real user-data dir on disk. */
   extension?: { path: string; /** F009.132 — a kept profile instead of a temp dir. */ profile?: string };
+  /** F009.136 — run in a named browser BUILD ('chrome' = the installed Google
+   *  Chrome) with its own user-data dir: a kept profile (where a site's login
+   *  lives) or a temp one. Google refuses a sign-in in Playwright's Chromium, so
+   *  YouTube Studio / Postmaster / the Web Store need this. Not with `extension`. */
+  browser?: RunBrowser;
+}
+
+export interface RunBrowser {
+  channel: ProfileChannel;
+  profile?: string;
+  /** Open a window instead of running headless — for a site that refuses even
+   *  de-flagged headless Chrome. Default false. */
+  visible?: boolean;
 }
 
 /** Exported for test: F074.57's central promise to everyone who did NOT ask for
@@ -337,6 +350,7 @@ async function launchWithExtension(
   const profile = opts.extension?.profile;
   for (let attempt = 1; attempt <= EXTENSION_LAUNCH_ATTEMPTS && !context; attempt++) {
     // F009.132 — a named profile is KEPT: that is where a site's login lives.
+    if (profile) bindProfileChannel(profile, EXTENSION_CHANNEL);
     userDataDir = profile ? profileDir(profile) : await mkdtemp(join(tmpdir(), 'lens-ext-'));
     try {
       context = await chromium.launchPersistentContext(userDataDir, {
@@ -382,6 +396,60 @@ async function launchWithExtension(
   return { context, extension: { id: new URL(bg).host, path: extPath }, userDataDir };
 }
 
+/** F009.136 — the same de-flagging the capture-session login window uses: no
+ *  --enable-automation (the "controlled by automated software" bar and the
+ *  navigator.webdriver flag) and AutomationControlled off. Exported so the build
+ *  and the flags are asserted, not assumed. */
+export function runBrowserLaunchOptions(b: RunBrowser) {
+  return {
+    channel: b.channel,
+    headless: b.visible !== true,
+    ignoreDefaultArgs: ['--enable-automation'],
+    args: ['--disable-blink-features=AutomationControlled', '--disable-dev-shm-usage'],
+  };
+}
+
+// Headless Chrome announces itself as "HeadlessChrome/<v>" in its user agent, the
+// first thing a sign-in page checks. The real agent is read ONCE per build from the
+// browser itself — never a hardcoded version string, which would be wrong after the
+// next Chrome update.
+const headlessAgents = new Map<ProfileChannel, Promise<string>>();
+function realUserAgent(channel: ProfileChannel): Promise<string> {
+  let ua = headlessAgents.get(channel);
+  if (!ua) {
+    ua = (async () => {
+      const b = await chromium.launch({ channel, headless: true });
+      try {
+        const page = await b.newPage();
+        return (await page.evaluate(() => navigator.userAgent)).replace('HeadlessChrome/', 'Chrome/');
+      } finally {
+        await b.close().catch(() => {});
+      }
+    })();
+    ua.catch(() => headlessAgents.delete(channel));
+    headlessAgents.set(channel, ua);
+  }
+  return ua;
+}
+
+async function launchRunBrowser(opts: WithPageOptions, b: RunBrowser): Promise<{ context: BrowserContext; userDataDir: string }> {
+  if (b.profile) bindProfileChannel(b.profile, b.channel);
+  const userDataDir = b.profile ? profileDir(b.profile) : await mkdtemp(join(tmpdir(), 'lens-run-'));
+  const userAgent = opts.userAgent ?? (b.visible ? undefined : await realUserAgent(b.channel));
+  try {
+    const context = await chromium.launchPersistentContext(userDataDir, {
+      ...contextOptions({ ...opts, ...(userAgent ? { userAgent } : {}) }),
+      ...runBrowserLaunchOptions(b),
+      timeout: EXTENSION_LAUNCH_TIMEOUT_MS,
+    });
+    return { context, userDataDir };
+  } catch (err) {
+    if (!b.profile) await rm(userDataDir, { recursive: true, force: true }).catch(() => {});
+    const msg = err instanceof Error ? err.message.split('\n')[0]! : String(err);
+    throw new Error(`browser "${b.channel}" did not start: ${msg}${b.channel === 'chrome' ? ' — is Google Chrome installed on the daemon host?' : ''}`);
+  }
+}
+
 export async function withPage<T>(
   opts: WithPageOptions,
   fn: (page: Page, context: BrowserContext, extension?: LoadedExtension) => Promise<T>,
@@ -431,6 +499,35 @@ export async function withPage<T>(
     }
   }
 
+  // F009.136 — a named build with its own user-data dir: its own launch and
+  // lifecycle, like the extension path, never the warm browser.
+  if (opts.browser) {
+    if (engine !== 'chromium') {
+      throw new Error(`browser.channel runs a Chromium-family build; engine "${engine}" cannot. Drop the engine option.`);
+    }
+    const b = opts.browser;
+    const release = b.profile ? claimProfile(b.profile) : () => {};
+    let launched: Awaited<ReturnType<typeof launchRunBrowser>>;
+    try {
+      launched = await launchRunBrowser(opts, b);
+    } catch (err) {
+      release();
+      throw err;
+    }
+    const { context, userDataDir } = launched;
+    try {
+      await context.addInitScript(READINESS_INIT_SCRIPT);
+      if (opts.prepareContext) await opts.prepareContext(context);
+      await applyStorageSeed(context, opts.seedStorage ?? null);
+      const page = context.pages()[0] ?? (await context.newPage());
+      return await fn(page, context);
+    } finally {
+      await withDeadline(context.close(), 5_000, 'browser context close').catch(() => {});
+      if (!b.profile) await rm(userDataDir, { recursive: true, force: true }).catch(() => {});
+      release();
+    }
+  }
+
   const makeContext = async (): Promise<BrowserContext> => {
     const browser = await withDeadline(getBrowser(engine), WEDGE_TIMEOUT_MS, 'browser launch');
     return withDeadline(

package/src/capture-session.ts

@@ -18,7 +18,7 @@
 // are confined to ~/.lens/state so a bad state_path can't clobber an arbitrary
 // file. The endpoint is loopback-only (127.0.0.1) behind the daemon's auth.
 
-import { claimProfile, profileDir } from './profiles.ts';
+import { bindProfileChannel, claimProfile, profileDir, type ProfileChannel } from './profiles.ts';
 import { EXTENSION_CHANNEL } from './browser.ts';
 import { chromium, type Browser, type BrowserContext, type Page } from 'playwright';
 import { z } from 'zod';
@@ -62,10 +62,12 @@ export interface FinishableSession {
 /** F009.132 — a login for a kept profile must happen in the SAME browser build
  *  the extension runs use (Google binds its session to the browser), visibly, so
  *  a human can type the password and 2FA. Exported so the build is asserted. */
-export function profileLaunchOptions() {
+export function profileLaunchOptions(channel: ProfileChannel = EXTENSION_CHANNEL) {
   return {
     headless: false,
-    channel: EXTENSION_CHANNEL,
+    // F009.136 — 'chrome' when the runs that will use this profile run in Google
+    // Chrome; the default stays the extension runs' build.
+    channel,
     ignoreDefaultArgs: ['--enable-automation'],
     args: ['--disable-blink-features=AutomationControlled'],
   };
@@ -376,6 +378,8 @@ export async function startCaptureSession(input: {
   loadStatePath?: string;
   /** F009.132 — log in INSIDE the kept profile ~/.lens/profiles/<name>. */
   profile?: string;
+  /** F009.136 — the build the profile's runs use (default the extension build). */
+  channel?: ProfileChannel;
 }): Promise<{
   sessionId: string;
   url: string;
@@ -407,10 +411,12 @@ export async function startCaptureSession(input: {
   if (input.profile) {
     // F009.132 — the login lands in the profile itself; the state file written at
     // finish is a copy for runs that do not use the profile.
+    const channel = input.channel ?? EXTENSION_CHANNEL;
+    bindProfileChannel(input.profile, channel);
     const dir = profileDir(input.profile);
     releaseProfile = claimProfile(input.profile);
     try {
-      context = await chromium.launchPersistentContext(dir, profileLaunchOptions());
+      context = await chromium.launchPersistentContext(dir, profileLaunchOptions(channel));
     } catch (err) {
       releaseProfile();
       throw err;
@@ -419,7 +425,7 @@ export async function startCaptureSession(input: {
     browser = { close: async () => { try { await context.close(); } finally { release(); } } } as unknown as Browser;
     // Measured 16 Oct: the channel build runs as this app, not "Chromium" — activating
     // "Chromium" failed and the window stayed behind the others.
-    appName = 'Google Chrome for Testing';
+    appName = channel === 'chrome' ? 'Google Chrome' : 'Google Chrome for Testing';
   } else {
     ({ browser, appName } = await launchHeaded());
     // Load an existing storageState so the browser opens ALREADY authenticated

package/src/daemon-routes.ts

@@ -110,8 +110,15 @@ export function registerDaemonRoutes(r: Hono, deps: LensDeps): void {
       password?: string;
       load_state_path?: string;
       profile?: string;
+      channel?: string;
     };
     if (!body.url) return c.json({ ok: false, error: 'url required' }, 400);
+    if (body.channel !== undefined && body.channel !== 'chrome' && body.channel !== 'chromium') {
+      return c.json({ ok: false, error: 'channel must be "chrome" or "chromium"' }, 400);
+    }
+    if (body.channel !== undefined && typeof body.profile !== 'string') {
+      return c.json({ ok: false, error: 'channel applies to a profile login — pass profile too' }, 400);
+    }
     // F009.132 — with a profile the login lives in the profile; the state file is
     // an optional copy and defaults next to the other states.
     const statePath = body.state_path ?? (typeof body.profile === 'string' ? join(homedir(), '.lens', 'state', `profile-${body.profile}.json`) : undefined);
@@ -124,6 +131,7 @@ export function registerDaemonRoutes(r: Hono, deps: LensDeps): void {
         password: body.password,
         loadStatePath: body.load_state_path,
         ...(typeof body.profile === 'string' ? { profile: body.profile } : {}),
+        ...(body.channel ? { channel: body.channel as 'chrome' | 'chromium' } : {}),
       });
       // F240.10 — pass the window verdict through UNCHANGED. A remote caller is the
       // one who has to tell a human "the browser is open"; it must see what the

package/src/flow.ts

@@ -23,7 +23,7 @@ import {
   type AssertOutcome,
   type Target,
 } from '@broberg/lens-engine';
-import { withPage, type LensEngine } from './browser.ts';
+import { withPage, type LensEngine, type RunBrowser } from './browser.ts';
 import { collectNetworkShapes, type NetworkShapesOptions, type NetworkShapesReport } from './network-shapes.ts';
 import { deadline, defaultPopupOf, prepareExtension, seedExtensionStorage, SIMULATED_ACCESS_NOTE } from './extension-flow.ts';
 import { authPrepare, fetchMintJson, persistStorageState, persistTarget, type AuthConfig, type AuthEnv } from './auth/index.ts';
@@ -143,6 +143,9 @@ export type FlowStep =
   // URI; an array = a multi-file upload. Drives real add-photo/attach steps a DSL
   // could not before (fd-sundhed skadefoto-flow, lens-gap 019f581a).
   | { type: 'uploadFile'; testid: string; path: string | string[]; label?: string; timeout?: number }
+  // F009.136 — the CSS twin of uploadFile, for an input with no testid (YouTube
+  // Studio's sits in a shadow root; Playwright's CSS engine pierces open ones).
+  | { type: 'uploadSelector'; selector: string; path: string | string[]; frame?: string | string[]; label?: string; timeout?: number }
   // F213.3 — composite + control-flow verbs for FMC-level manuscripts.
   // autocomplete: type into a field, wait for the suggestion list to render, then
   //   pick a suggestion by visible text (pickText) or index (pickIndex) — a real
@@ -186,6 +189,10 @@ export interface Flow {
    *  standing in for the toolbar click (activeTab) a headless run cannot make;
    *  the original build is never written, and the report says it was simulated. */
   extension?: FlowExtension;
+  /** F009.136 — run in a named browser build with its own profile:
+   *  {channel:'chrome', profile:'<name>'} = the installed Google Chrome with a kept
+   *  login. Google refuses a sign-in in Playwright's Chromium. Not with extension. */
+  browser?: RunBrowser;
   /** F009.133 — record the SHAPE (never a value) of every call the page makes:
    *  fetch/xhr request + response bodies and WebSocket frames. */
   network_shapes?: true | NetworkShapesOptions;
@@ -482,8 +489,8 @@ export const STEP_TYPES = new Set([
   'fillSelector', 'clickSelector', 'waitForUrl', 'inspect',
   // F213.2 — interaction verbs
   'clear', 'press', 'drag',
-  // F213.6 — file upload
-  'uploadFile',
+  // F213.6 — file upload; F009.136 — by CSS selector
+  'uploadFile', 'uploadSelector',
   // F213.3 — composite + control-flow verbs
   'autocomplete', 'capture', 'conditional',
   // F255.7 — gate on the deployed build actually serving
@@ -549,6 +556,10 @@ export function parseFlow(input: unknown): Flow {
       ...(typeof e.profile === 'string' ? { profile: e.profile } : {}),
     };
   }
+  const browser = f.browser === undefined ? undefined : parseRunBrowser(f.browser);
+  if (browser && extension) {
+    throw new Error('flow.browser and flow.extension cannot be combined — an extension run picks its own build; keep a login with flow.extension.profile instead');
+  }
   persistTarget(f.auth as AuthConfig | undefined); // F009.131 — refuse a persist that cannot be honoured
   validateAndNormalizeSteps(f.steps);
   // F009.133 — refused when malformed, for the same reason as extension above.
@@ -574,11 +585,33 @@ export function parseFlow(input: unknown): Flow {
     ...(f.wait_for_build !== undefined ? { wait_for_build: f.wait_for_build } : {}),
     ...(f.eject_grace_ms !== undefined ? { eject_grace_ms: f.eject_grace_ms } : {}),
     ...(extension ? { extension } : {}),
+    ...(browser ? { browser } : {}),
     ...(networkShapes ? { network_shapes: networkShapes } : {}),
     steps: f.steps as FlowStep[],
   };
 }
 
+/** F009.136 — refused when malformed, never dropped: a run that silently fell
+ *  back to Chromium would land on Google's "browser not secure" page and look like
+ *  a login problem. Exported so lens_run_manuscript validates the same way. */
+export function parseRunBrowser(input: unknown): RunBrowser {
+  const shape = 'browser must be {channel: "chrome" | "chromium", profile?: "<name>", visible?: boolean}';
+  const b = input as Record<string, unknown>;
+  if (!b || typeof b !== 'object' || Array.isArray(b) || Object.keys(b).some((k) => !['channel', 'profile', 'visible'].includes(k))) {
+    throw new Error(shape);
+  }
+  if (b.channel !== 'chrome' && b.channel !== 'chromium') throw new Error(`${shape} — channel is required`);
+  if (b.profile !== undefined && (typeof b.profile !== 'string' || !/^[a-z0-9][a-z0-9-]{0,39}$/.test(b.profile))) {
+    throw new Error('browser.profile must be 1-40 characters of a-z, 0-9 and dash, starting with a letter or digit');
+  }
+  if (b.visible !== undefined && typeof b.visible !== 'boolean') throw new Error('browser.visible must be a boolean');
+  return {
+    channel: b.channel,
+    ...(typeof b.profile === 'string' ? { profile: b.profile } : {}),
+    ...(b.visible === true ? { visible: true } : {}),
+  };
+}
+
 function requestRegex(u: string): RegExp {
   try {
     return new RegExp(u);
@@ -701,6 +734,7 @@ export const STEP_FIELDS: Record<string, string[]> = {
   press: ['key', 'testid'],
   drag: ['testid', 'toTestid', 'by', 'steps'],
   uploadFile: ['testid', 'path'],
+  uploadSelector: ['selector', 'path', 'frame'],
   autocomplete: ['testid', 'value', 'option', 'pickText', 'pickIndex'],
   capture: ['testid', 'as', 'from'],
   conditional: ['testid', 'present', 'steps'],
@@ -891,12 +925,12 @@ function validateAndNormalizeSteps(steps: unknown[], depth = 0, inParallel = fal
       throw new Error('press step requires a string key');
     }
     // F213.6 — uploadFile needs a string path or a non-empty string[] of paths.
-    if (s.type === 'uploadFile') {
+    if (s.type === 'uploadFile' || s.type === 'uploadSelector') {
       const p = (s as { path?: unknown }).path;
       const ok = typeof p === 'string' ? p.length > 0 : Array.isArray(p) && p.length > 0 && p.every((x) => typeof x === 'string' && x.length > 0);
       if (!ok) throw new Error('uploadFile step requires a non-empty string path or string[] path');
     }
-    if ((s.type === 'fillSelector' || s.type === 'clickSelector') && typeof (s as { selector?: unknown }).selector !== 'string') {
+    if ((s.type === 'fillSelector' || s.type === 'clickSelector' || s.type === 'uploadSelector') && typeof (s as { selector?: unknown }).selector !== 'string') {
       throw new Error(`${s.type} step requires a string selector`);
     }
     if (s.type === 'fillSelector' && typeof (s as { value?: unknown }).value !== 'string') {
@@ -1170,7 +1204,7 @@ function splitFrame(s: string): [string, string[] | null] {
  */
 export const MANUSCRIPT_VERBS = [
   'goto', 'click', 'fill', 'select', 'check', 'uncheck', 'clear',
-  'press', 'drag', 'upload', 'autocomplete',
+  'press', 'drag', 'upload', 'uploadSelector', 'autocomplete',
   'waitFor', 'waitForUrl', 'waitForBuild',
   'expectText', 'expectVisible', 'expectEditable', 'expectAbsent', 'expectTopmost',
   'fillSelector', 'clickSelector',
@@ -1321,6 +1355,18 @@ function parseManuscriptStep(s: string): FlowStep {
         ...(frame ? { frame } : {}),
       };
     }
+    case 'uploadselector': {
+      // F009.136 — "uploadSelector <css> = <fixture>[, <fixture>…]" (optionally
+      // "@frame <css>" after the selector). Same fixtures and sandbox as upload.
+      const eq = s.indexOf('=');
+      if (eq < 0) throw new Error(`uploadSelector step "${s}" needs "<css selector> = <fixture path>"`);
+      const [main, frame] = splitFrame(s.slice(0, eq));
+      const selector = main.replace(/^uploadSelector\s+/i, '').trim();
+      const rhs = s.slice(eq + 1).trim();
+      if (!selector || !rhs) throw new Error(`uploadSelector step "${s}" needs "<css selector> = <fixture path>"`);
+      const parts = rhs.startsWith('data:') ? [rhs] : rhs.split(',').map((x) => x.trim()).filter(Boolean);
+      return { type: 'uploadSelector', selector, path: parts.length === 1 ? parts[0]! : parts, ...(frame ? { frame } : {}) };
+    }
     case 'clickselector': {
       const [main, frame] = splitFrame(s);
       return {
@@ -1387,7 +1433,7 @@ function subst(str: string, vars: Record<string, unknown>): string {
  *  only its value. cardmem's flow 62ca6136 sent `[data-go="{{s}}"]` to Playwright
  *  literally on all 9 iterations. Other step kinds are returned unchanged. */
 function bindSelectorVars(step: FlowStep, vars: Record<string, unknown>): FlowStep {
-  if (step.type !== 'fillSelector' && step.type !== 'clickSelector') return step;
+  if (step.type !== 'fillSelector' && step.type !== 'clickSelector' && step.type !== 'uploadSelector') return step;
   const frame = step.frame == null ? step.frame : Array.isArray(step.frame) ? step.frame.map((f) => subst(f, vars)) : subst(step.frame, vars);
   return {
     ...step,
@@ -1539,6 +1585,7 @@ function describe(step: FlowStep): string {
     }
     case 'fillSelector': return `fillSelector ${step.selector}`;
     case 'clickSelector': return `clickSelector ${step.selector}${step.at ? ` @ ${step.at}` : ''}`;
+    case 'uploadSelector': return `upload ${Array.isArray(step.path) ? `${step.path.length} files` : (step.path.startsWith('data:') ? 'data:…' : step.path)} → ${step.selector}`;
     case 'waitForUrl': return `waitForUrl ${step.url}`;
     case 'inspect': return step.html ? `inspect html${step.testid ? ` [${step.testid}]` : ''}` : step.frame ? 'inspect @frame' : 'inspect';
     case 'drag': return `drag ${step.testid} ${step.by ? `by ${step.by.x},${step.by.y}` : `→ ${step.toTestid}`}`;
@@ -1847,7 +1894,7 @@ export function ejectionOf(loaded: string, current: string): string | null {
  * trust in the instrument.
  */
 const NAVIGATES_BY_DESIGN = new Set([
-  'goto', 'click', 'clickSelector', 'press', 'drag', 'autocomplete', 'uploadFile',
+  'goto', 'click', 'clickSelector', 'press', 'drag', 'autocomplete', 'uploadFile', 'uploadSelector',
   'waitForUrl', 'waitForBuild',
   // Every one of these can route on a change handler: a search box that submits,
   // a <select> that filters by URL, a checkbox that writes a query param.
@@ -2438,6 +2485,17 @@ async function execStep(page: Page, step: FlowStep, base: string, vars: Record<s
       await page.locator(sel(step.testid)).first().setInputFiles(files, { timeout: stepTimeout(step) });
       return null;
     }
+    case 'uploadSelector': {
+      const b = bindSelectorVars(step, vars) as typeof step;
+      const paths = Array.isArray(b.path) ? b.path : [b.path];
+      const isData = (p: string) => p.startsWith('data:');
+      if (paths.some(isData) && !paths.every(isData)) {
+        throw new Error('uploadSelector: a step must be all data: URIs OR all fixture paths, not a mix');
+      }
+      const files = paths.every(isData) ? paths.map(dataUriToPayload) : paths.map((p) => resolveFixturePath(localPath, p));
+      await resolveLocator(page, b.selector, b.frame).first().setInputFiles(files, { timeout: stepTimeout(step) });
+      return null;
+    }
     case 'waitForUrl': {
       const want = subst(step.url, vars);
       await page.waitForURL((u) => u.toString().includes(want), { timeout: stepTimeout(step) });
@@ -3197,6 +3255,7 @@ export async function runFlow(flow: Flow, env: AuthEnv, opts: RunFlowOptions = {
         reducedMotion: opts.reducedMotion,
         ...(videoDir ? { recordVideoDir: videoDir } : {}),
         ...(prepared ? { extension: { path: prepared.dir, ...(flow.extension?.profile ? { profile: flow.extension.profile } : {}) } } : {}),
+        ...(flow.browser ? { browser: flow.browser } : {}),
       },
       async (page, context, ext) => {
         videoPage = page;

package/src/mcp.ts

@@ -29,6 +29,18 @@ import {
   lensExport,
 } from './service.ts';
 
+const browserSchema = {
+  type: 'object',
+  required: ['channel'],
+  description:
+    'F009.136 — run in this browser BUILD with its own user-data dir. {channel:"chrome", profile:"<name>"} = the installed Google Chrome with the kept profile ~/.lens/profiles/<name>, de-flagged (no automation bar, no navigator.webdriver, no HeadlessChrome in the user agent). Use it for Google sign-ins (YouTube Studio, Postmaster Tools, Chrome Web Store), which refuse Playwright\'s Chromium ("this browser may not be secure"). Log in ONCE via POST /lens/capture-session {url, profile, channel:"chrome"} (a visible window; a human types password + 2FA), then reuse the profile in any run and from any project. A profile remembers its build: using it with the other channel is refused. One run per profile at a time. visible:true opens a window instead of headless. Not with extension.',
+  properties: {
+    channel: { type: 'string', enum: ['chrome', 'chromium'] },
+    profile: { type: 'string', description: '1-40 chars a-z 0-9 -. Omit for a fresh temp profile.' },
+    visible: { type: 'boolean' },
+  },
+};
+
 const authSchema = {
   type: 'object',
   description:
@@ -362,6 +374,7 @@ export const TOOLS = [
                 'F255.7 — do not start until the app is serving the build under test. A commit sha waits for THAT build; true waits for any change from the build live at run start. Polls GET /api/health for a `build` field (the fleet contract), from the runner with no-store, requiring 3 consecutive matching reads so a fleet mid-rollout cannot end the wait early. Fails loudly if the app exposes no marker. Use it right after a deploy — otherwise a green run may be verifying the build you just replaced.',
             },
             auth: authSchema,
+            browser: browserSchema,
             network_shapes: {
               type: ['boolean', 'object'],
               description:
@@ -392,7 +405,7 @@ export const TOOLS = [
   {
     name: 'lens_run_manuscript',
     description:
-      `Compile a human-readable markdown manuscript (fmc-automation style: "# flow: name", "base: <url>", then one "- <verb> …" per line) into a flow and run it E2E. VERBS (${MANUSCRIPT_VERBS.length}, this is the complete list): ${MANUSCRIPT_VERBS.join(' / ')}. Shapes: "- goto /x" · "- fill [testid] = value" · a PASSWORD without plaintext: "- fill [testid] from file <path>" (absolute, or relative to local_path) or "- fill [testid] from env <NAME>" (F009.121 — password inputs only; the value never appears in the run, the report or a screenshot) · "- click [testid]" · "- press Enter" (global) or "- press Enter [testid]" (on a focused element) · "- expectText [testid] ~ text" · "- drag [source] -> [target]" or "- drag [node] by 120,-40" (a canvas offset; both move in 10 mousemoves so React Flow / d3-drag nodes really move — "steps N" to change, F009.123) · "- upload [input-testid] = <fixture>" · "- assert: <js>" · "- screenshot label" · frame-aware "- fillSelector <css> = <value> @frame <iframe>" and "- clickSelector <css> @frame <iframe>" · "- waitForUrl <substring>". TWO BROWSERS AT ONCE (F009.122): prefix a step with "in <name>:" — "- in b: goto /" · "- in b: expectText [note] == Hej" — and it runs in its own browser (own cookies + storage), open alongside the default one for the rest of the run; steps without the prefix run in the default browser. Click modifiers: "- click [testid] via enter" (F255.1, for Angular/MDC buttons a mouse click does not activate) and "- click [testid] @ 50%,28%" (F255.4, aim at a point inside a canvas/3D surface). A field that already HOLDS a value may no longer render an input — a combobox typically swaps to its selected state, so "fill" times out there while "press ArrowDown" / "press Enter" still drive it (fd-sundhed, 2026-08-21). The authoring shortcut — write prose, not JSON.`,
+      `Compile a human-readable markdown manuscript (fmc-automation style: "# flow: name", "base: <url>", then one "- <verb> …" per line) into a flow and run it E2E. VERBS (${MANUSCRIPT_VERBS.length}, this is the complete list): ${MANUSCRIPT_VERBS.join(' / ')}. Shapes: "- goto /x" · "- fill [testid] = value" · a PASSWORD without plaintext: "- fill [testid] from file <path>" (absolute, or relative to local_path) or "- fill [testid] from env <NAME>" (F009.121 — password inputs only; the value never appears in the run, the report or a screenshot) · "- click [testid]" · "- press Enter" (global) or "- press Enter [testid]" (on a focused element) · "- expectText [testid] ~ text" · "- drag [source] -> [target]" or "- drag [node] by 120,-40" (a canvas offset; both move in 10 mousemoves so React Flow / d3-drag nodes really move — "steps N" to change, F009.123) · "- upload [input-testid] = <fixture>" · an input with NO testid, also inside an open shadow root: "- uploadSelector <css> = <fixture>[, <fixture>]" (F009.136; fixtures repo-relative to local_path or data:) · "- assert: <js>" · "- screenshot label" · frame-aware "- fillSelector <css> = <value> @frame <iframe>" and "- clickSelector <css> @frame <iframe>" · "- waitForUrl <substring>". TWO BROWSERS AT ONCE (F009.122): prefix a step with "in <name>:" — "- in b: goto /" · "- in b: expectText [note] == Hej" — and it runs in its own browser (own cookies + storage), open alongside the default one for the rest of the run; steps without the prefix run in the default browser. Click modifiers: "- click [testid] via enter" (F255.1, for Angular/MDC buttons a mouse click does not activate) and "- click [testid] @ 50%,28%" (F255.4, aim at a point inside a canvas/3D surface). A field that already HOLDS a value may no longer render an input — a combobox typically swaps to its selected state, so "fill" times out there while "press ArrowDown" / "press Enter" still drive it (fd-sundhed, 2026-08-21). The authoring shortcut — write prose, not JSON.`,
     inputSchema: {
       type: 'object',
       required: ['project', 'manuscript'],
@@ -408,6 +421,7 @@ export const TOOLS = [
         timezone: timezoneSchema,
         reduced_motion: reducedMotionSchema,
         storage: storageSchema,
+        browser: browserSchema,
         record: {
           type: 'boolean',
           description: 'F255.5 — record the whole driven run as a .webm and return it as video_url. Off by default.',

package/src/profiles.ts

@@ -1,7 +1,7 @@
 // F009.132 — a fixed browser profile per site. Google binds its session to the
 // browser that holds it, so a login only survives if it happens in, and is reused
 // from, ONE profile of ONE browser build. The profile lives on the daemon host.
-import { mkdirSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 
@@ -29,3 +29,26 @@ export function claimProfile(name: string): () => void {
   inUse.add(name);
   return () => inUse.delete(name);
 }
+
+// F009.136 — a profile is bound to the browser BUILD it was first used with. Google
+// keeps the session in the profile but checks it against the browser holding it, so
+// a Chromium profile opened in Chrome (or the reverse) is a mystery logout on the
+// next run. The build is written into the profile on first use and a mismatch is
+// refused before a browser starts, naming both.
+export type ProfileChannel = 'chrome' | 'chromium';
+const MARKER = '.lens-channel';
+
+export function bindProfileChannel(name: string, channel: ProfileChannel): void {
+  const marker = join(profileDir(name), MARKER);
+  if (!existsSync(marker)) {
+    writeFileSync(marker, channel, { mode: 0o600 });
+    return;
+  }
+  const bound = readFileSync(marker, 'utf8').trim();
+  if (bound !== channel) {
+    throw new Error(
+      `browser profile "${name}" belongs to ${bound} — this run asked for ${channel}. A login lives in the build it was made in; ` +
+        `run with channel "${bound}", or log in again under a new profile name for ${channel}`,
+    );
+  }
+}

package/src/service.ts

@@ -33,7 +33,7 @@ import {
   listBaselineVersions,
   revertBaseline,
 } from './store.ts';
-import { runFlow, parseFlow, compileManuscript, type FlowResult, type FlowStepResult } from './flow.ts';
+import { runFlow, parseFlow, parseRunBrowser, compileManuscript, type FlowResult, type FlowStepResult } from './flow.ts';
 // F074.24 — the daemon HOSTS the engine's own runFlow for flat cloud-shape
 // FlowRequests (one wire-shape, driven via @broberg/lens-client). The engine
 // natively speaks the cloud grammar (all 12 action-verbs), self-heals via the
@@ -999,6 +999,8 @@ export interface RunManuscriptInput {
   auth?: AuthConfig;
   /** F082.6 — repo root for relative auth + manifest-auth inheritance. */
   local_path?: string;
+  /** F009.136 — {channel:'chrome', profile?, visible?}: run in that browser build. */
+  browser?: unknown;
   /** F252.2 — run the manuscript at a non-default viewport/device so mobile-only
    *  UI (behind lg:hidden etc.) can be click-driven, not just DOM-asserted. */
   viewport?: { width: number; height: number } | string;
@@ -1030,6 +1032,11 @@ export async function lensRunManuscript(deps: LensDeps, input: RunManuscriptInpu
     throw new Error('manuscript (markdown string) is required');
   }
   const flow = compileManuscript(input.manuscript);
+  // F009.136 — the manuscript language has no browser line; the call carries it.
+  if (input.browser !== undefined) {
+    if (flow.extension) throw new Error('browser and extension cannot be combined — keep a login with extension.profile instead');
+    flow.browser = parseRunBrowser(input.browser);
+  }
   // F082.6 — a manuscript inherits the project's manifest auth (DRY: the
   // credential lives in one place) unless it declared its own.
   // F074.36 — an explicit `auth` argument outranks both, and the provenance is