81 Commits
Author SHA1 Message Date
5b61f221aa fix(core): stop launch() hosts from driving one mobile device (#2008)
* fix(core): give each launch() host a target name of its own

Every launch() host named its target after its platform and started as
worker slot 0, so every mobile host drove the agent-device session
e2e-ios-0: the session of another host, or of a runner worker on an
unnamed ios target. The mobile pool keeps a device its own session name
holds, so the host took that device and both tapped one screen.

A host's target is now <platform>-launch-<pid>-<n>. An agent's replay
cache keys to the platform, so recordings still replay on any host.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(core): draw a random token per launch() host, renamed after resolution

The pid and a module counter repeated across worker threads and across
two copies of the package in one process, so two hosts could still share
a device session. A random token per host does not. The platform part is
cut to 40 characters, so a long engine name still fits in the artifact
folder name, and the target is renamed only after its config resolved,
so config errors name the target as the program wrote it. The replay
cache keys on the resolved name.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(core): leave a long platform out of a launch() host's name, and forget finished bindings

A platform cut to 40 characters could keep part of a secret the
redactor only knows whole, so a longer platform is left out of the name.
The token is 96 random bits. The mobile engine's finish now forgets the
target's bindings, so one engine reused by host after host no longer
keeps every finished host's device and daemon address.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs(core): say how several launch() hosts share a machine's devices

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs(core): say when appPath hosts can share a device, and test the 40-character name boundary

A host holds its device once its app opens, so two appPath-only hosts
launched back to back can bind one device. The recovery command now
takes the session name from the error, quoted, and names daemon stop.
The changeset said "the token alone" where the name is host-<token>.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(core): name a launch() host's artifact folders after its token, not its platform

An engine's platform can be a secret's value, and the folder name
core/<target>-<attempt> put it on disk under artifactsDir, where
redaction never reaches. The folders are now core/host-<token>-<attempt>.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs(core): install an appPath build before opening it, and keep recovery to what the error names

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(core): pass launch() hosts to engines as hostId, keep target name

The random token no longer renames the host's target. Core hands it to
prepare, init and finish as hostId, and the mobile pool adds it to the
session name: e2e-<target>-<token>-<slot>. Fixtures, notices, errors,
provider tags and the replay cache key see the target name the program
wrote, so the cacheTarget indirection and the 40-character rule go.

* test(mobile): check a launch() host's init resumes the session its prepare warmed

The pool test now also has the host keep a device its own session holds
and runs init with the host's id: a surface whose init named the session
without hostId passed the old test and fails this one. Also moves the
SessionNamer doc comment back above its type.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(mobile): hand a launch() host's device bindings over a variable of its own

With the target keeping its name, a host opened inside an `e2e run` test
inherits the run's environment, where the run already left its bindings
for a target of the same name. A host's worker without the bindings in
memory (an engine served in another process) read the run's and drove
the device the test holds. The variable's digest now includes hostId.

Also names the host form of the session in `DeviceSession.session` and
the reference's `session` default, and mirrors the session option's
comment into the ja and zh references.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(mobile): fail a launch() host's close when its session stays open

A host's session name carries a random hostId, so no later host or run
takes its device back by name. finish now reports a session that will
not close, with its name, and counts one that is already gone as closed.
A run's worker and a session option keep their names and stay quiet.

Also from review: raise the @e2e-dev/core peer floor to 0.24.1, the
first release that sends hostId; bump e2e and web in the changeset and
say what a crashed host leaves behind; use pnpm dlx for agent-device in
the docs; drop a test that passed on main.

---------

Co-authored-by: michal-e2e <357875193+michal-e2e@users.noreply.github.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: Oskar Kwaśniewski <oskar@okwasniewski.com>
2026-11-21 13:33:12 +00:00
Samanyu DasandClaude Opus 5.5 7a8e546e26 fix(mobile): fail toHaveScreenshot with POLICY_DENIED when a secure field can't be masked (#2014)
* test(mobile): expect a screenshot mobile withheld to be refused for masking

On mobile, a screenshot the engine cannot mask is withheld with no sign it
was ever taken, so toHaveScreenshot waits out its timeout and fails with
ASSERTION_FAILED, and the agent is told the engine captures no pixels. These
tests expect the engine to report the regions it masked (none) beside the
missing pixels, toHaveScreenshot to fail at once with POLICY_DENIED, and the
agent to read MASKING_UNPROVEN. A screenshot that was never taken, or one
withheld with every secure field masked, still keeps the matcher waiting.

Refs #1996

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(mobile): fail toHaveScreenshot with POLICY_DENIED when a secure field can't be masked

When a secure node on the mobile screen has no bounds, the engine cannot
mask it, so it drops the screenshot and reports nothing else. The session
could not tell that from a screenshot that failed, and the matcher checked
for missing pixels before it checked masking, so it polled until its timeout
and failed with ASSERTION_FAILED and "the engine returned no screenshot". On
the web the same case fails at once with POLICY_DENIED, which is what the
docs and AGENTS.md promise. The agent had the same gap: it was told the
engine captures no pixels (UNSUPPORTED_CAPABILITY) instead of
MASKING_UNPROVEN.

The engine contract now lets an engine withhold a screenshot it could not
mask by reporting maskedRegionCount without pixels. The mobile engine does
so for a secure node without bounds. An image it cannot read or decode is
still no screenshot, so the matcher takes another. When the count falls
short of the secure nodes, the session marks the observation
pixelsWithheld: 'MASKING_UNPROVEN', the token the agent already uses for
unproven pixels. toHaveScreenshot fails with POLICY_DENIED on it, and the
agent passes it on. A screenshot that was never taken (the web engine
mid-navigation, a failed device capture) reports no count, so the matcher
keeps waiting for it as before.

app.screenshot() on the same screen failed with ENGINE_FAILURE (exit 3)
for the same cause. It now fails with POLICY_DENIED too, as AGENTS.md
asks for withheld pixels. An image that cannot be decoded keeps
ENGINE_FAILURE, since there is no screenshot to withhold. Failure evidence
and agent evidence screenshots catch every error, so neither changes.

Fixes #1996

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* refactor(core): decide withheld pixels once, in the session

The session now keeps pixels on an observation only when the masked regions
cover every secure node, and marks any screenshot the engine took without
that proof, sent or withheld, as `pixelsWithheld: 'MASKING_UNPROVEN'`.
`toHaveScreenshot` and the agent's `clearPixels` read that one field and no
longer check the masking themselves.

The mobile engine reports a secure node without bounds as unbounded before
it reads the image, since no image makes that screen maskable, and drops
`decodesAsPng`. `redactSecure` returns a tagged result, and the
`ENGINE_FAILURE` message for an image it cannot read says so.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(core): keep fallback pixels only when their masking is proven

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* test(core): isolate the unproven fallback pixels case

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(mobile): withhold pixels on an unbounded screen without a screenshot

A secure field without bounds makes the screen unmaskable from the tree
alone, so the mobile engine now checks the bounds before it takes a
device screenshot. `observe` reports no regions masked and
`app.screenshot()` fails with `POLICY_DENIED`, even when the device
screenshot would have failed, and neither pays a device round trip.

Lists `POLICY_DENIED` under `app.screenshot()` in the app reference, and
says `maskedRegionCount` is reported when the harness asks for pixels.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs(core): name pixelFallback as a pixels request in the count contract

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(core): mark pixels withheld only for a pixels request

The session now marks an observation `MASKING_UNPROVEN` only when the
caller asked for pixels, so the engine contract needs no rule about when
an engine reports `maskedRegionCount`. The masking check on fallback
pixels runs after the bare-root check, so a malformed unavailable tree
keeps `INVALID_STATE`. Tests pin the masked count the agent passes on.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs(core): name pixels: true in the withheld count contract

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* test(mobile): pin the error category of a withheld app.screenshot()

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(core): leave fallback pixels to the engine's own masking proof

An unavailable tree is a bare root, so the session has no secure node to
count, and checking the masked-region count against zero proves nothing.
The engine that sends fallback pixels proves their masking itself.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-21 13:53:30 +01:00
Daniel PetroandOskar Kwaśniewski e88153b2f3 feat(locator): add blur for web elements (#1919)
* feat(locator): add blur for web elements

* fix(locator): declare blur against the required core version

* fix(locator): cover MathML blur and engine capabilities

* docs(locator): list blur in action references

* fix(web): require core and e2e 0.24.1 for locator actions

---------

Co-authored-by: Oskar Kwaśniewski <oskar@okwasniewski.com>
2026-11-20 15:58:39 +00:00
Oskar Kwaśniewski 8eb3cc27ea fix(web,mobile): name engine handle types for inferred configs (#1976) 2026-11-19 18:09:30 +02:00
Krzysztof MochandOskar Kwaśniewski 847a09e6db feat(test)!: set fixtures up on demand, once per worker, and in beforeAll (#1891)
* feat(test): set fixtures up once per worker and pass them to beforeAll

test.extend() takes [fn, { scope: 'worker' }]: one instance per worker and
target, torn down when the worker ends. Suite hooks receive worker fixtures.
Engines can declare isolation: 'worker'; @e2e-dev/mobile does, so its device,
app, and screen reach beforeAll, afterAll, and worker fixtures.

Refs ENG-1297

* feat(e2e)!: set up fixtures on demand

A test now sets up only the test.extend() fixtures its body and its
beforeEach and afterEach hooks name in their first parameter, the fixtures
those name, and the auto ones. A suite hook sets up the worker fixtures it
names and the auto worker fixtures. Names are read from the function's
source, as Playwright and Vitest read them.

- [fn, { auto: true }] and [fn, { scope: 'worker', auto: true }] run a
  fixture nothing names.
- A fixture can name the fixtures declared beside it in the same extend()
  call. Fixtures run in declaration order, each after the ones it names.
- The attempt is resolved as one unit before the session launches: a
  fixture only an afterEach names is set up before the first beforeEach.
  An afterEach that names a fixture whose setup failed is skipped.
- Fixture rules fail as COLLECTION_ERROR with the file and line of the
  code: a parameter that is not destructured or takes a rest property, and
  a cycle, when the file is collected; a name the target lacks, a test
  fixture named by a suite hook or a worker fixture, and a fixture named
  like an engine's, at selection, for the pairs that run on that target.
- On an engine with isolation: 'worker', a suite hook or a worker fixture
  teardown that names no engine-backed fixture opens no engine attempt.

BREAKING CHANGE: a fixture nothing names no longer runs unless it is
declared with auto: true, and a test body, hook, or fixture function that
takes the whole fixture object (async (fixtures) => {}) no longer loads.

Refs ENG-1297

* refactor(core): declare core fixtures in one table

The five core fixtures (agent, app, screen, platform, session) are one
table in @e2e-dev/core: name, scope, and factory. createFixtures builds
the built-ins object through one loop over that table and the engine's
factories, every fixture a lazy accessor behind the same gate as before.

The runner's fixture pool, test.extend() validation, and launch read the
names and scopes from the table, so the name lists and the per-name scope
checks are gone. A launch session exposes the core fixtures that do not
belong to a test: app, screen, platform.

No behaviour change. app and screen were built with the attempt and are
now built on first read, like agent and the engine's fixtures.

Refs ENG-1297

* feat(e2e): extend a built-in fixture through test.extend

A test.extend() fixture named like one the test already has extends it,
by Playwright's rule: inside its function its own name is the fixture it
extends (the built-in, or an earlier fixture of that name), and tests,
hooks, and other fixtures that name it receive what it hands to use().

  base.extend({ device: async ({ device }, use) => {
    await device.setPermission('camera', 'deny');
    await use(device);
  } })

- A plain function takes the scope the extended fixture has on the
  target: device is a worker fixture on mobile, so its override runs once
  per worker and reaches beforeAll; app is a test fixture on web and a
  worker fixture on mobile. A declared scope that differs is a
  COLLECTION_ERROR naming both.
- A worker-scoped override receives what a worker fixture receives for
  that built-in, the forwarder to the attempt that is running.
- On a target without the built-in nothing fails until code that runs
  there names it; then the target has no such fixture.
- Only user code sees the override: the attempt's own built-ins, which the
  runner and the worker fixtures' forwarders read, are untouched.
- Types: the override keeps the extended fixture's type and scope, through
  an extend() overload that takes overrides without type arguments.

A fixture named like a core fixture, an engine's, or an earlier one of the
chain was refused before.

Refs ENG-1297

* docs(fixtures): name built-in fixtures and give their scope per engine

The docs now use one term, built-in fixtures, for agent, app, screen,
platform, session, and the ones an engine contributes (browser, device),
where pages said core fixtures, contributed fixtures, or engine fixtures.

The test reference gets one table with each built-in fixture's scope on
web and on mobile, and says what the scope decides: a test fixture reaches
test bodies, beforeEach, and afterEach; a worker fixture also reaches
beforeAll, afterAll, and worker fixtures. The hooks, worker fixtures, and
override sections link to it, as do the fixtures guide and the engine
pages. The Japanese and Chinese pages carry the table and the same terms.

Refs ENG-1297

* docs(ja): translate the fixture scope and on-demand changes

* docs(zh): translate the fixture scope and on-demand changes

* fix(e2e): let a worker fixture name an extended app or screen

A fixture that extends `app` or `screen` was taken for a test fixture when
its test.extend() call was checked, before any target is known. A worker
fixture declared after it that names `app` then failed at import on every
target, though the same fixture is accepted without the override and the
plan resolves both to worker scope on an engine whose state outlives a
test.

The scope of a plain function is now unresolved until a target is known,
whatever it extends, as it already was for an engine's own fixtures.

Refs ENG-1297

* fix(e2e): fail a suite hook that left an engine step running

On an engine whose state outlives a test, a beforeAll or afterAll hook, or
a worker fixture's teardown, can start a device step and not await it. The
hook's attempt then closed under the step, and its failure arrived later
as a stray rejection charged to whichever test ran then.

The suite attempt now does what a test attempt does once its body settled:
the step is failed at its call and cancelled, its outcome is awaited within
the cleanup budget, and the hook fails with STEP_NOT_AWAITED (HOOK_FAILED
for a suite hook).

The suite attempt keeps no step records, and StepRecorder dropped the
record of the step it had just opened before marking it running, so there
was nothing to abandon: a step now counts as running before the retained
window is trimmed.

Refs ENG-1297

* refactor(e2e): keep the fixtures a function names beside it

Registration parsed each test body, hook, and fixture function for the
fixtures it names, dropped the result, and left it in a WeakMap that the
planner and the pool read back with placeholder subjects. A cache miss
there would have named the wrong code and no line.

The parse result is now data: `names` on the registered test, the hook,
and the fixture definition. The planner and the pool read it, the WeakMap
and the per-function wrappers are gone, and one describeUser() gives an
error its subject. The explore test, registered by hand, parses its body
where it builds the record.

Unit tests state the names instead of generating source text for them.

Refs ENG-1297

* refactor(core): resolve built-in fixtures in one place

The core table declared the core fixtures, but what a target's built-in
fixtures are was still assembled around it: core names plus engine names in
three files, the 'engine' scope resolved in e2e through a cast into the
table, `platform` hard-coded as the one fixture that needs no attempt, and
two structural copies of the target.

core now exports builtInFixtures(target): names, scope(name),
needsAttempt(name), attemptless(name), and the unknown-fixture message,
over one BuiltInTarget. `platform` declares in the table that the target
alone decides it. launch, the planner, and the pool read from it.

DECLARED_BUILT_INS is the same view before a target is known: a scope the
engine decides is 'unresolved'. The planner takes either one, so its
no-target mode and the `target === undefined` branches through scopeOf and
read are gone. The scope of a fixture that extends `app` before a target
is known is 'unresolved' by construction.

Refs ENG-1297

* refactor(e2e): hand each function the fixtures it names

Every test body, hook, and fixture function must destructure its first
parameter, so what it reads is known before it runs. bindFixtures still
built a Proxy-gated bag for arbitrary property reads: one value in three
stores, the gate run twice (once over a faked plan), a third derivation of
scope, and an own-name shadow that re-derived what the planner had resolved.
No test code could reach the gate's throwing branches; only unit tests did,
by reading the bag directly.

The plan now records, per function, what each name it reads resolved to: a
chain fixture or a built-in. The pool hands each function a plain object
with exactly those names, the value a chain fixture handed over, or a
built-in read off the attempt when the function destructures it, so
built-ins stay lazy. An override that names itself receives the fixture it
extends because that is what its own name resolved to.

- bound.call(user) replaces user.fn(bound.fixtures); ready(user) asks
  whether every chain fixture it names was provided.
- attemptlessBuiltIns is a function from a name to a value that throws the
  reason for a built-in that needs an attempt.
- The planner runs once: it records what each fixture names, and the order
  is one declaration-order walk over that record. A second validating pass
  only reordered.

Behaviour: a bound or native function, whose parameters cannot be read, is
a COLLECTION_ERROR; it used to parse as naming nothing and still got lazy
built-ins. The docs no longer promise hooks and the body one shared object.

Refs ENG-1297

* refactor(e2e): move the suite attempt out of TargetExecutor

dispose, openSuiteHooks, and openSuiteAttempt were 177 lines of a second
attempt lifecycle inside TargetExecutor, written as closures in one method.

run/suite-attempt.ts now owns it: a SuiteAttempt class with open, acquire,
within, and close, over a SuiteAttemptHost interface the executor satisfies
(the way serial.ts borrows it through SerialHost), plus the worker
fixtures' teardown pass. It is the realm's SuiteHookSession itself, so the
executor keeps a context object and two call sites.

The three branches that built an attemptless reader with a "not available
to the <label>" error are one NoAttempt value ('isolated', 'unnamed',
'interrupted', or the launch failure) and one mapper to the message.

execute.ts: 1244 lines to 1052.

Refs ENG-1297

* refactor(e2e): share the attempt's fixture sequence

A run's attempt and an `e2e mcp` session's test each planned the test's
fixtures, bound them, entered the worker pool, set them up, ran the
beforeEach hooks and the body, filtered the afterEach hooks that can still
run, and labelled the teardowns. This PR widened that copy, and
standalone-test.ts asked the realm for the same hooks four times.

planAttemptFixtures(target, test, hooks) plans before any session exists
and returns open(), which binds the plan to the attempt: enter(), run()
for setup, hooks, and body, and cleanup() for the labelled afterEach hooks
and teardowns. Both call sites keep their own phases, budgets, and error
handling around it.

execute.ts: 1052 lines to 1031, its size on main.

Refs ENG-1297

* refactor(e2e): open the suite-hook pass without a lazy thunk

withSuiteHooks handed its work a thunk that opened the pass on first use.
Opening one does no I/O: the suite attempt launches nothing until a hook
that names an engine fixture runs. The pass is now opened up front and
closed in finally, and the `opened` slot and the `hooks()` call form go.

Refs ENG-1297

* refactor(e2e): ask the registry which hooks apply to a test

The selection-time fixture check rebuilt the scope chain of a test and
filtered the file's hooks by it, which the realm already did its own way.
registry.ts now exports scopeChain(test) and hooksFor(registration, test),
and both use them.

Refs ENG-1297

* refactor(core): move the fixture types into types/fixtures.ts

types.ts grew from 1679 to 1798 lines in this PR. The fixture scope, the
worker fixtures, and what test.extend() takes (definitions and overrides)
are one coherent group that nothing else in the file defines against, so
they move to types/fixtures.ts and types.ts re-exports them. The public
surface is the same.

types.ts: 1798 lines to 1715.

Refs ENG-1297

* refactor(core): drop the redundant override branch in FixtureDefinitions

A fixture that extends one the base already has was typed three ways: a
conditional branch inside the `Extra` map of FixtureDefinitions, the
`& FixtureOverrides` intersection, and the extend(overrides) overload.

Compiling the type tests without each in turn: the intersection types an
override written beside new fixtures with type arguments, and the overload
types an override-only call without them; both fail the tests when
removed. The conditional branch does not: with it gone the tests pass, and
a base name in `Extra` is `never` again, as it was before overrides. It is
removed, and the reference's copy of the declaration follows.

Refs ENG-1297

* refactor(e2e): split fixture errors from the parser, share hookLog

fixture-names.ts parses a parameter list, and also held FixtureUseError and
declarationSite, which format an error. They move to fixture-errors.ts.
Its identifier pattern held two raw zero-width characters; they are
written as escapes now.

hookLog and LOG_MODULE were pasted into three integration tests; they are
one helper in tests/helpers/hook-log.ts.

Refs ENG-1297

* docs(e2e): name the scope rule in the selection check's summary

The summary of assertFixtureUse still listed a chain fixture named like an
engine's as an error. Such a fixture extends the built-in now; the rule
left is a declared scope that differs from the extended fixture's.

Refs ENG-1297

* refactor(e2e): take execute.ts under 1000 lines

Two more pieces that are not the attempt's own sequence leave the file.

- Holding steps for `e2e run --step`: reading the screen a hold starts on
  and wiring AttemptHolds to the runner's hook move to step-hold.ts, beside
  the holds they configure (holdAttemptSteps, readHeldScreen).
- The result of a finished test or setup unit is a pure function of the
  pair, the verdict, the attempts, and a beforeAll failure: unitResult in
  units.ts, beside pairResult.

execute.ts: 1031 lines to 956. It was 1031 on main and 1226 at the review.

Refs ENG-1297

* test(e2e): match the not-awaited message without a step label

Main's #1880 names an unlabeled step by its api alone ("gadget.hang
finished"), where the message used to quote an empty label. The suite-hook
test's pattern required a label between the two, so it failed on the merge
with main.

* feat(e2e): an override inherits auto from the fixture it extends

A fixture that extends another and does not state `auto` now has the
extended fixture's, the way it has its scope: an override of an auto
fixture is set up for every test, and one of a built-in fixture on demand.
An `auto` that differs from the extended fixture's is a COLLECTION_ERROR
naming both, worded like the scope mismatch. This matches Playwright.

It also fixes which fixtures the plan starts from. An auto fixture was a
root by its own flag, so with an auto base and its override in one chain
the base was set up and the override skipped, while the name resolved to
the override; an override that replaced the base without naming it still
left the base running. An auto fixture is now a root only where its name
stands for it: the base runs once through the override's own name, or not
at all when the override replaces it.

Refs ENG-1297

* fix(core): name the hook or fixture that left a step running

STEP_NOT_AWAITED said "the test body returned before ..." for a step a
beforeAll, afterAll or beforeEach hook, a fixture's setup or a worker
fixture's teardown left running. The recorder now keeps the owner each
step was started under, and the runner says which code runs: the pool
for fixtures, hooks and the body, the suite attempt for suite hooks, and
a hosted session for itself.

---------

Co-authored-by: Oskar Kwaśniewski <oskar@okwasniewski.com>
2026-11-18 13:09:51 +00:00
Donny/강동윤andClaude Opus 5.5 0cd14a0dfa perf(core): read a wait again at 20 and 50 ms, then every 100 ms from its start (#1834)
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 19:29:29 +02:00
dbe3dc54a9 feat(core): add launch, SessionState, and createAgent to @e2e-dev/core (#1734)
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: Oskar Kwaśniewski <oskar@okwasniewski.com>
2026-11-16 09:38:07 +01:00
0a5ee16387 refactor: move e2e's core into @e2e-dev/core, and engines peer on it (#1737)
* refactor: move e2e's core into @e2e-dev/core, and engines peer on it

The engine contract, locators, agent, replay cache, secrets, and the
session half of a worker move from packages/e2e to packages/core, the new
@e2e-dev/core package, at the same paths. e2e depends on it at its exact
version (a changesets fixed group) and reaches its modules through
@e2e-dev/core/lib/*, which is not public API; e2e/engine and e2e/agent
re-export it. @e2e-dev/web and @e2e-dev/mobile peer on @e2e-dev/core and
import the contract from @e2e-dev/core/engine. Install smoke checks that one
copy of @e2e-dev/core is installed.

Most of this diff is git mv and import specifiers rewritten to
@e2e-dev/core/lib/<path>; no behavior changes.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* ci: build and pack @e2e-dev/core where e2e is built or packed alone

The Bun job built e2e before the @e2e-dev/core it compiles against, and the
examples nightly installs e2e from a tarball whose exact @e2e-dev/core is
not on npm; it now packs @e2e-dev/core and overrides it in each example.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs(engines): name @e2e-dev/core/engine as the contract's source

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(e2e): list @e2e-dev/core beside an engine in init and upgrade

Engines peer on @e2e-dev/core. Yarn installs no peer the project does
not list, and under Plug'n'Play the engine then fails to load.

- init adds @e2e-dev/core with any engine
- upgrade adds a required @e2e-dev peer the project lacks, and keeps a
  package e2e depends on at the version e2e names

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: Oskar Kwaśniewski <oskar@okwasniewski.com>
2026-11-15 18:31:58 +00:00
Łukasz LechandOskar Kwaśniewski 0b4485989d feat(agent): read computed styles in project tools (#1633)
Co-authored-by: Oskar Kwaśniewski <oskar@okwasniewski.com>
2026-11-15 15:49:17 +01:00
Donny/강동윤andClaude Opus 5.5 0920ef5f94 feat(web): tabs in the browser fixture, with switch_tab and close_tab agent verbs (#1710)
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 17:00:57 +00:00
Krzysztof Moch 046bd08f4a fix(web)!: scope headers and basicAuth to the app's origin (#1393) 2026-11-12 08:49:48 +00:00
Xiangxuan Qu d1b0ff61c2 feat(e2e): add screen.doubleTapAt for viewport gestures (#1331)
* feat(web): add coordinate double-click to browser mouse

* test: handle Unicode checkout paths in hosted-session fixtures

* test(web): simplify double-click regressions after review

* feat(e2e): add screen.doubleTapAt for viewport gestures
2026-11-11 13:49:51 +01:00
Kacper Kapuściak f185ca8ba2 docs: retire sidebar page icons (#1582)
* docs: retire sidebar page icons

The docs sidebar no longer shows icons. Drop icon: from every page's frontmatter, delete the grey silhouettes in docs/images/icons/, and make check-docs-logos fail on any frontmatter icon instead of requiring one on vendor pages. Card logos stay required. The authoring-docs skill trades its Page icons section for a short Vendor logos one.

* docs: require a migrate overview card for each migration guide

* docs: match only top-level icon keys in check-docs-logos
2026-11-05 18:23:59 +00:00
Oskar Kwaśniewski 4dce5a7685 fix(web): tap position from inside the border, port the remaining click tests (#1547) 2026-11-05 10:49:20 +01:00
Oskar Kwaśniewski d2953bb9bb feat(e2e): timeout 0 means no step deadline; settle by-design Playwright gaps (#1554) 2026-11-05 09:40:25 +01:00
Oskar Kwaśniewski 0c0469605a chore: replace e2e.tester.army with e2e.com (#1572) 2026-11-05 09:23:45 +01:00
Oskar Kwaśniewski a8ed7f76c6 fix(e2e): let setInputFiles([]) clear a file input (#1546) 2026-11-04 19:56:14 +01:00
Oskar Kwaśniewski cba5e0ecfb feat(agent): resize_viewport verb for responsive layouts (#1524) 2026-11-03 19:32:56 +01:00
Oskar Kwaśniewski 91bd61490d feat(cli): e2e doctor preflight with engine doctor hook (#1493) 2026-11-03 10:27:52 +01:00
Oskar KwaśniewskiandTotopo27 57f9ed9eda fix(mobile): bound reads by operation budget with last-read grace (#1464)
Co-authored-by: Totopo27 <35828647+Totopo27@users.noreply.github.com>
2026-10-31 12:08:44 +01:00
Oskar Kwaśniewski 3f43edd166 feat(engine): engine protocol for out-of-process engines (#1232)
* feat(engine): engine protocol for out-of-process engines

The engine contract as LSP-style JSON-RPC: connectEngine turns a server
into an engine handle, serveEngine serves any defineEngine handle, and
spawn, socket, and loopback transports reach it. Abort reasons, errors,
and pixels cross intact; the manifest has a JSON schema for servers in
other languages. E2E_ENGINE_LOOPBACK=1 runs every engine through the
protocol in process; the testbed runs that way in CI.

* feat(engine): run every in-process engine over the protocol, drop E2E_ENGINE_LOOPBACK

* refactor(engine): drive engine protocol from one method table

- one METHODS table feeds describeEngine, server and client
- client builds the engine from the manifest, defineEngine validates it
- harness holds only protocol clients (EngineClientHandle)
- signals scoped to attempts, drop $/release
- worker connections queue for MCP session handover
- track attempts for servers without startAttempt
- locate/stopVideo return arrays, keyboard/type takes options

* feat(engine): let connectEngine answer session hooks on the client

Host-side relaunch (simctl) without wrapping the client in defineEngine,
which made the harness serve it over loopback a second time.

* docs(engine): group engine docs into one Engines section

New Engines overview and Engine servers guide; the protocol reference
keeps signatures, messages and errors.

* docs(engine): complete config examples, drop leftover OG card

* fix(engine): harden protocol from review

- bound finish/dispose hooks by their budget, always close transport
- late endAttempt retires only its own attempt (client and server)
- reject malformed error responses instead of throwing from stream
- resolve a secret once; server derives redacted forms via attempt/deriveSecret
- carry error stack, errno, and causes across the wire
- serveEngine always answers startAttempt/endAttempt, so signals are freed without hooks
- detach signal listeners when a connection closes
- refuse a server speaking another protocol version
- docs: platform in connectEngine examples, message and error updates

* fix(engine): fixed diagnostic for malformed error response
2026-10-31 10:28:53 +01:00
Oskar Kwaśniewski 94e6e76548 feat(agent)!: keep model screenshots after a secret fill (#1437) 2026-10-28 19:11:24 -07:00
Marcos Penelas CámaraandOskar Kwaśniewski 7518ae5b2d feat(agent): add drag_at to the pixel tools (#1282)
Co-authored-by: Oskar Kwaśniewski <oskar@okwasniewski.com>
2026-10-28 14:25:16 -07:00
Krzysztof Moch 3a841bb99e feat(web): grant browser permissions from a web target's app.permissions (#1429) 2026-10-28 13:33:46 -07:00
Oskar Kwaśniewski d2ffb319cf feat(e2e): record one span of the screen with app.startRecording and app.stopRecording (#1381)
* feat(e2e): record one span of the screen with app.startRecording and app.stopRecording

* docs(e2e): name the video modes app.startRecording refuses under
2026-10-28 03:06:09 +00:00
Krzysztof Moch 90e6fb8bef fix(agent): tap_at and hover_at send the bare point when the engine takes one (#1284) 2026-10-23 12:30:17 -05:00
Oskar Kwaśniewski da13624d31 feat(runner): run only the tests a pull request can affect (#1206) 2026-10-23 12:29:15 -05:00
137b50f0c8 feat(locator): combine alternatives with or (#1049)
Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: Oskar Kwaśniewski <oskar@okwasniewski.com>
Signed-off-by: Rudy Celekli <rudy@gradiahq.com>
2026-10-22 12:39:22 -04:00
Mateusz Zatorski ef977f4856 fix(mobile): retain leased device sessions during worker replacement (#1209) 2026-10-17 16:12:13 +02:00
Kacper Kapuściak c304924e53 docs(reference): rewrite the API reference in the Next.js shape (#1197)
* docs(reference): rewrite the API reference in the Next.js shape

Every reference page now opens with a lede and a minimal example, groups its
API under ## sections that start with a summary table linking to one ###
entry per member, and keeps the TypeScript declarations under ## Types.

* docs(reference): fix claims the review caught

Narrow the security summary rows to their sections, generate the screenshot
file name in the engine example instead of building it from the label, and
correct defaults, exit codes, and examples on config, cli, screen, web,
mobile, test, runner, and engine.

* docs(reference): address review findings

Scope error classes to runner errors, guard a zero-slot prepare in the engine
example, keep the cli #help-and-version anchor, and correct poll cancellation,
same-run screenshots, openLink schemes, type_secret, longPress durations,
runner signals and close failures, empty usernames, and the feedback exit
code. Make the reporter and extract examples self-contained.

* docs(reference): trim the summary tables to the minimum

Each group's summary table keeps the linked name and one or two short
columns (type, default, or a few-word description). Examples and details
live in the entries; facts that only a table cell held moved into its entry.
The expect overview is headed Reference instead of Entry points, and the
security rules table names what each section covers instead of restating
its claims.

* docs(reference): open every page's API under one Reference heading

Each page's first section after the lede is now ## Reference. A page with
one group lists its entries at ### right under it; a page with several keeps
each group as a ### with its summary table and its entries at ####.
Explanatory sections (behavior, budgets, setup, types) follow it. Linked
sub-parts that moved to ##### keep their anchors through explicit ids.

* docs(skills): describe the reference page shape in authoring-docs

Reference pages open their API under ## Reference, keep summary tables to
the name and one or two short columns, and nest entries at ### or ####
because Mintlify drops anchors below ####. ship-pr points reference edits
at these rules instead of the guide shortening pass.

* docs(reference): address cubic review on tables and skill

Keep readonly in the mobile device type, show the keyboard and mouse
object shapes, say a locator assertion times out as ASSERTION_FAILED, and
give reference pages a narrower shortening pass in authoring-docs.

* docs(reference): tighten the reference pages

Merge facts said twice into one place, move each declaration's JSDoc to a
single home, link timeout defaults, key grammar, and secure-field rules to
the pages that own them, and split long sentences. No fact is cut.

* docs(reference): address cubic review of the tightening pass

Qualify the GitHub token for fork pull requests, provider recording URLs,
duplicate device entries, MODEL_UNAVAILABLE timing, the APP_UNREACHABLE log
quote, UNKNOWN_TOOL versus UNSUPPORTED_CAPABILITY, node-less agent tools,
which model receives screenshots, passing assert evidence, and config-path
hosts; fix three garbled sentences.

* docs(reference): say device, not simulator, for worker isolation
2026-10-16 14:41:30 +00:00
Michał PobutaandClaude Opus 5.5 2791786ced feat(mobile): match Android test ids without their package prefix (#1178)
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 14:42:28 +02:00
Oskar Kwaśniewski 236611fafb docs: fix packaged docs against source, ship snippets, check anchors (#1168)
* docs: fix packaged docs against source, ship snippets, check anchors

* docs: tighten review wording, harden anchor check fences and ids

* docs: address review on tool errors, CLI failure output, anchor check

* docs(security): base64 is decoded in text downloads

* docs(telemetry): shorten the telemetry page (#1174)

* docs(telemetry): shorten the telemetry page

* docs(telemetry): engine versions are semver or unversioned

* docs(migrate): shorten the Playwright migration guide (#1172)

* docs(debugging): shorten the debugging guide (#1170)

* docs(auth): merge repeated secret facts on the signing-in page (#1169)
2026-10-15 17:56:13 +02:00
Prajwal VedulaandOskar Kwaśniewski 5fce7b2bfe feat(engine): pass the measured keyboard state to executors (#883)
* feat(engine): carry a measured keyboard state from the engine to executors

EngineSnapshot and ExecutorObservation gain an optional keyboardVisible:
whether an on-screen keyboard is showing, as the engine measured it apart
from the tree. false means it measured none; the field is omitted only
when the engine did not measure it. The session copies it onto the
semantic observation and the observation feed hands it to the executor, so
an executor no longer has to infer the keyboard from keyboard and key
nodes that a platform may list only in part.

It is a boolean, not the producer's band: dismissing the keyboard only
needs to know whether one is up, and the band's frame is in the producer's
own coordinate space.

* feat(mobile): report the keyboard band agent-device measured on each observation

observe() sets keyboardVisible from the capture's keyboard fact: true for a
visible band, false for a proven absence, and nothing when the producer
could not measure it or published nothing. agent-device's iOS runner
publishes the fact with every capture; Android captures carry none, so
Android observations leave the field out.

The gesture fallback for dismissing the keyboard reads the same fact
through the same helper.

* feat(decision): offer dismiss_keyboard from the measured keyboard state

The action space reads the observation's keyboardVisible when the engine
measured one and falls back to the tree's keyboard and key nodes when it
did not. A keyboard the tree leaves out still offers the control, and key
nodes left behind after the keyboard closed no longer do.

The page fingerprint hashes the measured state beside the pixels, so a
dismissal that closes the keyboard without changing the tree no longer
reads as unchanged and cannot complete the three-action stall streak. An
unmeasured state hashes apart from a measured false.

* refactor: address review on measured keyboard state

- fingerprint takes the observation
- keyboardVisible checks use === undefined in every layer
- trim docs to one user-facing sentence, drop engine.mdx paragraph
- merge changesets into one patch changeset

---------

Co-authored-by: Oskar Kwaśniewski <oskar@okwasniewski.com>
2026-10-15 13:57:35 +02:00
Michał PierzchałaandClaude Opus 5.5 14b77d320e fix(mobile): bound each input by its budget (#1073)
* fix(mobile): bound each operation by its budget

The mobile engine bounded agent-device calls only by the operation's
signal, and the harness aborts that signal with the attempt, not at
timeoutMs. A device command that outlived actionTimeout held the step until
the test timeout. Each engine entry now runs under withinBudget, as the web
engine bounds its own: the call sees a signal that also aborts at
timeoutMs, whatever it throws after that is the budget's OPERATION_TIMEOUT,
and the timer ends with the call. Input verbs report the timeout as
ACTION_MAY_HAVE_COMMITTED so the runner never repeats a tap that may have
landed. The OperationContext.signal docs now say it does not abort at
timeoutMs.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(mobile): bound inputs only, each device command under the budget left

Bounding every entry broke a locator poll: its last snapshot, cut off at
the deadline, read as a timeout instead of a missing node, and an abandoned
read overlapped the next command. Only the device commands that send input
now run under the budget, through InputBudget.send: with no budget left an
input is not sent (OPERATION_TIMEOUT), and one that does not answer in time
is ACTION_MAY_HAVE_COMMITTED. Reads, including the relocation before a tap,
stay unbounded. An input sent with almost no budget left still gets 250 ms
to answer, and each command of a multi-command input is sent on its own, so
no keystroke follows a focus tap that used the budget up.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(mobile): refuse a hold the budget cannot cover, and document inputs that time out

A long press or timed swipe that holds at least as long as the budget left
could only be cut off mid-gesture, so it is refused before it is sent, as
NOT_ACTIONABLE naming the hold and the time left. An input counts as sent
only once its command was dispatched, so one that throws first is not. The
mobile guide says what an input that outlives its timeout does.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-13 13:57:00 +02:00
Kacper Kapuściak 5d4053e8fa docs: render an Open Graph card for every docs page with @vercel/og (#1062) 2026-10-12 15:10:32 +02:00
Oskar Kwaśniewski 5137778251 feat(expect): toHaveScreenshot visual comparison on web, iOS, and Android (#977) 2026-10-08 19:17:12 +02:00
Oskar Kwaśniewski 1b92a6ddfa feat: e2e trace pages replace the Playwright trace (#869) 2026-10-07 11:28:27 +02:00
Oskar Kwaśniewski e77c17ae0c fix(cache): drop the engine version from the replay cache key (#929)
Every engine minor re-keyed all committed recordings, so each `chore:
version packages` merge failed the strict web agent job with REPLAY_STALE
on main (#825 after #774). The key keeps the engine's name and SPI
version; a release of the same engine is caught at replay, where each
action re-finds its node. The 30 web benchmark entries move to their new
hashes by a re-key verified against the old ones.
2026-10-06 13:42:10 +00:00
Kacper Kapuściak 63482bd6fe docs: reorganize the sidebar into platforms and a deep dive (#870) 2026-10-05 20:39:06 +02:00
Mohit NeheteandOskar Kwaśniewski b33398fc38 feat(locator): duration option for path screen.swipe (#831) (#840)
Co-authored-by: Oskar Kwaśniewski <oskar@okwasniewski.com>
2026-10-05 16:43:52 +02:00
Oskar Kwaśniewski c83b86f491 fix(web): fail operations on a hung page at their timeout, not the test timeout (#828) 2026-10-05 16:22:13 +02:00
Oskar Kwaśniewski 78e135a372 fix(secrets): redact plain-string secret values from traces and text downloads (#814)
* fix(secrets): rewrite traces and text downloads whenever the run has a secret value

A registered value a test passed as a plain string (an app.open URL, a fill)
was redacted from titles, labels, and agent input but kept verbatim in
trace.zip: trace and download rewriting was gated on the exposure level,
which only a fill or an engine-held secret raises. Rewriting now depends on
the session ledger holding a value. The engine exposure level had no other
consumer and is removed; exposure now only decides pixels and saved-session
taint.

* fix(secrets): cover a plain-string fill, scope docs to the session's known values

* docs(secrets): download redaction is whole-value; TRACE_WITHHELD outside-path case

* docs(secrets): name the download rewrite failure path
2026-10-04 10:34:34 +02:00
Oskar Kwaśniewski f0f9c8daae fix(security): allow only http(s) and about:blank on explicit navigation (#722)
* fix(security): allow only http(s) navigation, refuse wrapped schemes on device links

view-source:file:// passed the file:/data:/javascript: denylist and loaded local files via app.open, browser.goto, and the navigate verb. resolveNavigationUrl now admits http: and https: only; mobile links also refuse view-source:, blob:, filesystem:.

* fix(security): admit exact about:blank, sync rule text in AGENTS.md and SECURITY.md

* fix(web): refuse about:blank cookie URL, qualify scheme rule text
2026-10-03 13:16:39 +02:00
Oskar Kwaśniewski f7c0756666 fix(expect): waitFor attached/detached, absent-frame absence, toHaveProperty primitives, toHaveURL ignoreCase (#726)
Rebuilt on top of #579, which already landed matcher option flags, ignoreCase, and unknown-option refusal.
2026-10-02 20:00:51 +02:00
Oskar Kwaśniewski c6c39ad3f6 fix(expect): Playwright matcher options are honored or refused, never silently ignored (#579)
* fix(expect): matcher options are honored or rejected, never silently ignored

* refactor(web): reuse core rejectUnknownOptions, presence toHaveAttribute reads third arg

- e2e/engine exports rejectUnknownOptions; web drops its timeout-only copy
- toHaveAttribute(name, undefined, options) validates and times out on options
- waitForURL waitUntil refusal tested and noted in migration table

* docs(engine): rejectUnknownOptions takes code, options must be plain object

* fix(expect): toHaveAttribute refuses a null value or options; tests use the @e2e-dev scope

* fix(expect): use the browser fixture name after the web rename
2026-10-02 12:31:57 +02:00
Oskar Kwaśniewski 4d488f8286 feat!: the app is declared on its target; engines only drive it (#698)
* feat!: the app is declared on its target; engines only drive it

The app under test moves from the engine's options to `targets: [{ engine,
app }]`: `url`, `bundleId`, `appPath`, `identity`, `environment`,
`launchArguments`, `permissions`, `command`, and `readyUrl`. `web()` and
`mobile()` refuse every moved option in one `INVALID_CONFIG` naming the
target block; `defineEngine({ app })` is gone and engines check what their
platform needs in `validateApp`. `requires: ['browser' | 'native-app']` is
derived from the target's app. Replay cache and session keys are byte for
byte what they were, pinned by target-identity.test.ts.

Dependency services are not part of this version: `services` anywhere, and
`web({ services })`, fail saying so. `app.command` on port 0 without a
command, and `reuseExisting` on a free port, are refused. An `e2e mcp`
open cancelled or disconnected mid-start stops what it started, and a hung
shared start is abandoned once no session waits on it.

* fix: review follow-ups: cancelled opens, abandoned starts, null targets, stale docs

* refactor: drop the moved-option messages; old app keys are unknown keys

* test: give the replaced-nodes suite a budget that survives a loaded runner

* test: size the replaced-nodes hook budget to its seven tests
2026-09-30 19:48:00 +02:00
Oskar Kwaśniewski 10d392ea3c fix(config): follow-ups to the config redesign: output data loss, engine-held secrets, migration messages, agents (#662) 2026-09-30 14:04:23 +02:00
Oskar Kwaśniewski 0073644863 fix(config): refuse silent config mistakes: secret references as strings, nested unknown keys, directory globs (#670)
* test(skill): fail a skill or docs paragraph that passes the removed --artifacts

* fix(config): name the replacement for a removed createAgent import

* fix(config): keep the code of a config error raised while the config evaluates

* fix(secrets): refuse a secrets.get() reference where a string is needed

* fix(config): reject unknown keys in engine, command, test, and query options

* fix(config): refuse a tests entry naming a directory, name the ! entry excluding a positional

* refactor(config): derive option key lists from their types

* fix(config): one shared unknown-key check; drop undefined env values

Setup and describe option keys typed from their interfaces; a directory tests entry is INVALID_GLOB like a trailing slash.

* fix(collect): name the excluding ! entry when exclusions left nothing, and in on-disk casing

* fix(config): address review - exclusion hint for bare names, array env, qualified hints

* test(select): use a missing tmp root, not /root, which CI cannot stat

* fix(mobile): accept videoTouches, added on main by #671, in the mobile() key list

* fix(mobile): reject unknown permission names and states in mobile() and device.openApp

Names and states are checked against DevicePermission and PermissionState
through satisfies-typed key lists. INVALID_CONFIG at load, INVALID_ARGUMENT
from device.openApp, before any device command. rejectUnknownKeys takes an
optional code for the test-time case.

* fix(eas): reject unknown easSimulators() options with INVALID_CONFIG

Its options are its own, mapped onto EAS's create input, not a passed-through
SDK body, so a typo such as buildID was dropped silently. Its two other option
refusals are INVALID_CONFIG too. e2e is now a peer, for e2e/engine.

* fix(mobile): require a plain object for permissions; clarify eas and permission notes

A Map passed the object check with no own keys, and the preset applied none
of it.
2026-09-30 10:36:32 +02:00
Oskar Kwaśniewski 6b851bb604 docs: fix stale and wrong claims in guides (#653)
* docs: fix stale and wrong claims in guides

- output: --artifacts -> --output in bug-bash guide and skill; sessions and
  cache locations follow output / cache.dir in security; artifact path
  gains the agent segment in github
- ci: upload artifacts on !cancelled() in ci guide and skill
- mcp: several sessions (--max-sessions) in security
- replay cache naming: "Commit the replay cache" heading and anchors
  (old anchor kept, e2e init links the new one),
  trace replay -> replay cache in writing-an-engine and executors
- timeouts: STEP_TIMEOUT / STEP_BUDGET_EXHAUSTED advice names config
  timeout, judgmentTimeout, maxSteps, maxModelCalls (debugging, skill)
- mobile: app.open() in device examples and quickstart, mobileTools pack
  all mutating, Android toolbar anchor, drop agent-device release note
- executors: verdict code rules, missing ctx members and scrollUntil,
  a replay cache section; agent-steps passed+code rule
- migrate: swipe direction is the content's, `!` test exclusions,
  video row status, Kernel for Selenium Grid
- secrets: an unset env string fails config load, a provider's value is
  redacted only from its first fill; three secret sinks
- misc: Models link text, telemetry links outbound connections, integration
  config wording, web-only expect(web) in a cross-platform block,
  capabilities heading in engine reference, swipe direction in screen reference

* docs(skill): separate the credential redaction paragraph

* docs(reference): KERNEL_API_KEY names @e2e-dev/kernel
2026-09-29 23:38:52 +02:00
Oskar Kwaśniewski 8904b02ab5 docs(reference): fix stale and missing claims, sync JSDoc (#655)
* docs(reference): fix stale and missing claims, sync JSDoc

* docs(reference): only the built-in agent needs a model to acquire the fixture
2026-09-29 22:53:18 +02:00