Skip to content

Releases

v0.18.0

Choose a tag to compare

@deviate-dv8 deviate-dv8 released this 13 Nov 07:05
  • Pilot: click an orange outline, name it, and it is registered in the page's _sel.ts (19e57fd)
  • Pilot register: a selector picked in the browser is written into the page's _sel.ts (pilot register, session op) (4701c57)
  • States: word states beside booleans (needs [Key, value], sets [[Key, value]]); per-pane states; check walks panes; Studio menu for word states (b4874f7)
  • manifest spec: shopFlow signs in as the standard shopper (f331234)
  • Pilot coverage names the page and file:line of each selector; a hand-opened page's address params go on the trail (801e147)
  • check walks flows against state guards; map moves show +state/-state; saucedemo flows self-sufficient (episodes not exported) (046023c)
  • States: boolean mem keys declared state(); pages and shells needs them, Methods and links set them; the run applies and checks them (step:state), manifest lists them, Studio locks pages and has a switch per state; Sauce Demo uses signedIn (cc047ba)
  • Sauce Demo on the page-object shape: src/map/(shop)/ a page folder per URL, no Navs, no states file; flows with titles and labels; menu uses Method preconditions; docs follow (37d87da)
  • calls spec: the artifact is the file the step:call names (src and dist copies each have their own listeners) (b70c9a2)
  • Studio: the map follows a live session (you are here); docs (8884319)
  • Pilot: coverage on|off over the session protocol, the session keeps what the page shows on its trail; docs (8c310f2)
  • Docs: mem.trail, what earlier steps saw (652056f)
  • Block.stub replaces .stubAfter (narration after the step lands); .stubBefore and .stubOnError stay; upgrade --codemod stub (8c7ff8a)
  • on(): no non-null assertion (e221314)
  • MapBuilder.on(Page, p => ...): several Methods of one page as one call, each its own step (c5315f7)
  • Trail: what each step saw, kept on the run's mem (mem.trail.latest(Page.read.x)); joined steps record their read too (00c3a29)
  • Pilot coverage chip: registered elements green with their names, unregistered ones orange; param-aware unmapped-link check (c37f742)
  • Spec of your own on the new format (tested); Method params instead of .set in the convention and flows guide (82cbbf1)
  • Page.check(why, (read, mem) => boolean): one check primitive over everything the page shows; Key.passes removed, upgrade --codemod checks (398e5f3)
  • Studio API console: send a recorded call again, answer in words, copy as cURL or API Block; docs (02081b0)
  • ctx.ui.showCalls(), the card put on a wiped overlay (a step that navigated), demo spec for calls (a372a31)
  • network config: names for calls on the card, thresholds for check --network, overlay.calls; fixture page types no longer committed (0636dee)
  • Studio flows list keeps the export name beside a title; manifest test follows the flows' own labels (48b4d46)
  • Studio: a page's Network section (calls per route, findings) from the flows' newest runs; docs (8cded67)
  • Network findings (waygraph check --network), Studio run step calls with request and response; docs (b8927b3)
  • Saucedemo: hybrid UI + API flow with a seeding step (labels hybrid, api); quickstart synced (ba5d4af)
  • Demo: a step's HTTP calls on its outcome card, each opening a call modal with the request, the response and why; stories (4091e5b)
  • Calls as data: a run records each step's HTTP calls (the page's fetch/XHR, an API Block's request and response) as step:call events, bodies masked in the run's call artifacts (3b369cc)
  • Flows carry meta: title, description, labels (joined with the config's), ticket, owner; in list, manifest, run log, demo opening, Studio; check names flows without a description (d8385a1)
  • Codemod extract-methods: inline Methods become _methods/ files (the shape gen writes); examples, scaffold and quickstart on it (1a851ec)
  • Docs and skill: Methods are a file each in _methods/ (inline for one-liners); waygraph gen (5314153)
  • waygraph gen: page, method, flow, keys, account from the convention (a _methods/ file per Method, never overwrites); check lists selectors still TODO; page from: takes names (af25957)
  • Typed page names: waygraph types writes src/waygraph-pages.d.ts (global WaygraphPages), so to:/covers: complete and a typo is an error; typecheck and check rewrite it; shells are found by covers: in any block file (b58d725)
  • Studio screenshots for the page object (shell halos, last results) (b528ab2)
  • Studio docs and lint (ef0b24c)
  • Studio for the page object: shells as halos and a tag (no line per page), last-result dots, params moves, Pages tab, Find by move, results service; docs (4cf304a)
  • page.ts: under the line limit (5c50c32)
  • page.ts: under the line limit (149a086)
  • Manifest: pages (one record per Page Block with its moves, expectations, links, covers), and a Block's place in its page (group/owner/key, its own source span) (b499979)
  • 0.18.0: Studio in the page object's terms (shells, opens from / arrives when / shows / do / expects); version bump (7909788)
  • Method params: self.method((a, b) => spec), a Block per call (3072268)
  • graph snapshot: same edges, Blocks now live in their pages (f9e4729)
  • A page covers pages (covers, links, interrupts, opens, bare shells): no separate layout kind; defineLayout deprecated; saucedemo/scaffold shells migrated; docs and skills (ca24a88)
  • Methods and expectations live in the page: codemod inline-methods (also expectations), scan lists a page's do/expects as Blocks, saucedemo/scaffold/quickstart migrated (032d27c)
  • Convention: no method pollution (Methods are what a user can do, not test steps); codemod inline-methods also inlines expectations (f1d401f)
  • page.expect: expectations written in the page (no Expect Block files) (d36a7ce)
  • codemods: helpers move with their reads/stubs transitively, emptied files go (20b4904)
  • Docs and skill: a page is its own Checkpoint, inline Methods, frame, ctx.page.api, workaround table rows; codemods move helpers with their reads and stubs (4c563ae)
  • frame: a page in an iframe sees its locators scoped to the frame; ctx.page.api reads from the app's API with the page's session (Engine api); interrupts also in joined steps; codemod removes emptied _reads.ts (bca16fc)
  • A page is its own Checkpoint (checkpoint: "Login"), with inline Methods (page.method) defaulting from/to to the page; PageHandle for Methods in their own files (a233e41)
  • route: "folder": a page's address is its folder under src/map (1d62c84)
  • manifest: query typing (ae9e20d)
  • manifest: query typing (3618706)
  • Query params as page state (query, go, setQuery, arrival check); Studio page panel shows query and arrival checks (26a0305)
  • Page.go({ id }): a page with params in its address opens at one address, typed by them (1c0f310)
  • ROADMAP: what's left of the page object (1d51825)
  • Mem stubs live on the keys (keys(ns)({ field: () => value })); codemod mem-stubs; docs and skills (ba3d6c1)
  • Studio: Find (/ or Ctrl-K) for pages, flows and Blocks; a picked page comes into view; pages that open themselves are ways in and lines; layouts show their interrupts (a838f64)
  • Stage 2: a page opens itself (url/click/from on the Page Block); codemod nav folds Nav Blocks into their pages; examples, scaffold, docs, skills migrated (fbdc992)
  • Stage 4: Methods are written flat (act, precondition, verify, lands); codemod instructions; examples, scaffold, docs and skills migrated (9e6a48c)
  • Stage 3: layouts take interrupts (locator handlers per page): run event, manifest, demo card, docs (1e3e8d7)
  • Page object docs and skills: a page's read replaces Read Blocks (guides, reference, convention skill, agents, deprecated rows); lifecycle: do/expects as functions; manifest source for page reads (1dff4a8)
  • Page object: layouts take read as a page does (Layout.read keys, Layout.readBlock); the codemod moves an every-page Read Block into the layout over its folder; examples, scaffold and quickstart migrated (e152e72)
  • waygraph upgrade --codemod page-object: Read Blocks and reads() namespaces fold into the page's read; methods/expects thunks become do/expects functions; a Read Block with no Page Block becomes one. Validated on copies of two real projects (no new type errors, same read shapes). Saucedemo untouched here (2007703)
  • Page object, step 1: a Page Block takes read (its own Read Block, keys as Page.read.x) and do/expects as functions of the page, called on first use (87b2d4e)
  • Split view: one overlay on the stage, not one per pane: only the pane acting shows the chrome (banner, stepper, todos, caption, outcome, chips); the others show their page and its rings (data-passive, kept across page loads). The stage's pictures align top-left, so a size mismatch can't shift a page (7626c45)

Full changes: v0.17.2...v0.18.0

v0.17.2

Choose a tag to compare

@deviate-dv8 deviate-dv8 released this 11 Nov 11:20
  • 0.17.2 (cc39971)
  • Waygraph Studio's map: a shared link drawn from many pages shows its badge once, with how many lines it has (nav-x (28)); a flow filter in the bottom bar (by label or by flow name) shows only the pages those flows land on and the moves they play (a project's labels appear as label: ), kept per project (6baa26a)
  • Waygraph Studio's map: a link valid from several pages is counted on the page it leads to ('N shared links in', no threshold) and drawn when that page is selected; a Nav, Method or API badge on a line opens its Block's panel, as a page's list does (the label layer takes the pointer) (5b8590e)
  • Waygraph Studio's map: a link valid from many pages (a menu, a sidebar) draws its lines only for the page selected, and the bar counts the hidden ones (843 lines became 101 on a 70-page project); the other sites a project's pages live on sit together under one 'external' node apart from the app; a page whose address is a template with no path (file://:HOST_DIR/x.html, :url/review) isn't given invented folders (Studio and the manifest's siteTree) (56e85f2)

Full changes: v0.17.1...v0.17.2

v0.17.1

Choose a tag to compare

@deviate-dv8 deviate-dv8 released this 11 Nov 10:30
  • 0.17.1 (1a2852e)
  • Extensions load in every pane of a demo (the stage and windows): a pane with its own context is a persistent one with the extensions, as the run's own is (browser.newContext() never loads them: Hoppscotch's pane said 'extension not loaded'). Test with a local extension (cf0e533)
  • OpenSpec change page-object-model (replaces page-read-in-page-block): a page is one object (read, expects, do as functions of the page, key with its stub), nav from the folder with typed path and query params, interrupts on layouts, Methods without instruction; four stages, each with a codemod (9375ade)
  • OpenSpec change page-read-in-page-block (a page's read lives in its Page Block, types inferred, the Read Block kind goes, a codemod folds the files in); a 'How a run works' guide: loading, a step's phases, modes, and why a Page Block's entries are lazy (25db3dc)
  • OpenSpec change block-capabilities: a Block says how it plays (type, paste, set, click, blitz) and what it shows (a key and a value), a step overrides it; Hoppscotch's URL and JSON body stop typing and ring the key and value (476b330)

Full changes: v0.17.0...v0.17.1

v0.17.0

Choose a tag to compare

@deviate-dv8 deviate-dv8 released this 11 Nov 09:40
  • 0.17.0: Waygraph Studio, layouts and access, split view (experimental), typed panes, --compare, lock, test --flows filters (7443250)
  • API and network plans: a viewer must see what ran and how it went on the page: a live calls card (running, good or bad, status in words), bursts as counts, calls alongside a step shown with it, and a verdict in words (769b484)
  • OpenSpec change api-requests-and-races: API clients as values (their own request context, as an account, or a pane's cookies), a burst (times) and calls alongside a browser step, results as data in the run log, demo and Studio (b7801b3)
  • Panes are values: const Guest = pane('guest', { as: ProblemUser }), then map({ panes: [Main, Guest] }), .in(Guest), .close(Guest), with: Main. Nothing is a string: rename and go-to-definition reach every flow, and panes are shared between flows. Examples, scaffold, tests, type tests, split view guide, convention skill; the deprecated page's 0.17.0 section has the old form (6f9b12e)
  • The banner's tag has an icon for where the demo is: a window for one page, columns for the split view; the split view pill is gone. allFeaturesShowcaseFlow opens the inventory in the guest pane first (its cart link wasn't on the page, so the demo waited on a click that could never land) (986f139)
  • A demo locks the page against the person watching it (a shield under the chrome, a locked/unlocked chip bottom-left toggles it; the panel's Next still works). The split view's mark moves to the top centre (off the zoom chip) and a single pane on the stage has no header. Demo guide (6410829)
  • Split view: one stepper panel for the whole flow (the acting pane shows it, the others' are put away); the panel's header says 'waygraph stepper'; the stage shows the cursor the pane's page would (hand, text bar) over its picture (b58b761)
  • The split view's stage takes less room: no padding, a 2px gap, a 20px label strip, and a small 'split view' mark always in the corner so a recording says it's split. ROADMAP: a virtual address bar (f845c54)
  • saucedemo: deviceShowcaseFlow is allFeaturesShowcaseFlow (npm run demo:showcase): phone, tablet, landscape, zoom and todos, then split view with a second shopper's pane opening beside the first and closing. waygraph try demo runs the quickstart's own chained-flows test (the quickstart carries saucedemo's tests) (bdd5c99)
  • Waygraph UI is Waygraph Studio: waygraph studio (waygraph ui says it's waygraph studio now), the app in studio/ built into dist/studio, npm run studio / studio:dev, the Studio guide (/guides/studio, its screenshots in docs/public/studio, npm run docs:studio-shots), its window and wordmark. Every page, comment, skill, CI step and active OpenSpec change says Studio; the deprecated page has the row (c6d1507)
  • Panes work as one page does, everywhere: the stage passes what's done on it to the pane under the pointer (clicks, scrolling, keys), so a demo with panes is driven like one on a single page (Next, Retry, Stop; no forced auto-advance); the run's voice-over speaks for every pane; more than two panes share the stage as a grid; any pane closes, the first one too (its person leaves the run's own page, and it reopens afresh); --compare plays a flow with panes too (each pane once per side, .close() closing each side's). The Split view guide loses its limits. Tests (f2fdca9)
  • qa-network-and-api-view: a failed call never fails its step (no option either); everything works the same with one page and with panes (14ce663)
  • OpenSpec change qa-network-and-api-view: what a step called, with the step, in words (named calls, status in words, failed calls marked, third-party noise left out), an API step's own card (request, response and checks as tables), the panel rebuilt for QAs, and the calls in the run log and Waygraph UI (93c9b39)
  • waygraph test --flows: --label, --grep and --grep-invert go on both flows projects, not the command line. With an exclusive flow in the project, a filter that picked it (a label covering it) ran every other flow first: the exclusive flows' project depends on the rest, and Playwright runs a dependency unfiltered by the command line, but filtered by its project's own grep. Test, testing guide (f77690c)
  • Split view, documented: a Split view guide page (panes, .in(), with, one screen to two and back with .close(), the stage, windows, --video-panes, --compare, lanes in Waygraph UI, limits), the flows, demo and UI guides, the CLI and run log references (pane, compare:diff, the manifest's panes), the convention skill and planner agent, ROADMAP. The scaffold's email verification shows the mail catcher and the app side by side (0b71ab7)
  • One screen, then split, then one again: .close(pane) closes another pane (its context, with the panes sharing it) and the flow goes on in the one it's in; .in() it again and it opens afresh. On the stage only the open panes show: one fills it, a second splits it, a closed one gives the room back, and the panes it sizes are resized (through the demo's own resize). twoShoppersFlow goes from the standard shopper alone, to both, to one again. Tests (66cc0e5)
  • Waygraph UI: a flow with panes and its runs as lanes, one per pane, each step at its place in the flow so the arrows read in order across them; a step says its pane; a compared run marks each step where the two sides differed (compare:diff now names the two run steps). The map's left-out note uses the run colour. Tests (3f823a9)
  • --compare as=a,b | device=a,b | config=a,b: one flow played twice, side by side, step by step, as two panes named for the sides (a config side is a pane on that config's baseUrl); after each step the run compares where the sides landed, whether they passed and what each page read, logs each difference (compare:diff) and prints a summary; a side that fails stops while the other plays on, and the run fails. A demo shows both on the stage. Tests (60159cb)
  • Split view: a flow with panes played as a demo or a video shows them side by side on a stage, the session's own window (demo/split/stage.ts): each pane plays out of sight in a browser of its own and streams its screencast to its place, labelled with who is signed in and its device, the acting pane marked; each pane has the demo's UI on its own page, and the stage moves on by itself. --split windows puts each pane in a real window instead, side by side across the screen; --video-panes also records each pane. twoShoppersFlow opens the inventory in each pane first. Tests (bcf9359)
  • Panes: map({ panes }) declares a flow's pages side by side, each in its own browser context (its account, its device) or sharing a pane's (with); .in(pane) says where the next steps act, and TypeScript checks each step against its pane's page. Each step plays on its pane's page from where that pane last landed (run/pane-page.ts, which the run loop and joined steps ask); a pane opens and signs in on first use and closes with the flow; switching pane sets its account's mem again; errors and the run log name the pane. waygraph run, test --flows and the manifest (a flow's panes, each step's pane) play and list them. saucedemo: a second account and twoShoppersFlow. MapBuilderOptions moves to map-options.ts. Tests (7f08e12)
  • OpenSpec change split-view: panes in a flow (map({ panes }), .in(pane), own or shared context, an account and device per pane), a stage that shows them side by side as one window and one video (CDP screencasts) or tiled windows, and --compare to play one flow twice in step and report the differences (c6f95e5)
  • npm run test:offscreen: on Linux with xvfb, the Playwright suite on a hidden display (xvfb-run), headed tests included. Developing reference (affe7cc)
  • Docs: Your project is the project's shape and its opinions (the tree, one page folder, each opinion with why and what holds you to it: waygraph map, waygraph check, TypeScript, the access tests). The Waygraph UI guide is a tour with screenshots (the map, a page, a layout, the legend, dark, flows, a flow, runs, a failed run, Blocks, Project) and how it works; the home page shows it. npm run docs:ui-shots makes the screenshots from a copy of examples/saucedemo with a clean run log (7be515c)

Full changes: v0.16.21...v0.17.0

v0.16.21

Choose a tag to compare

@deviate-dv8 deviate-dv8 released this 10 Nov 21:04
  • 0.16.21 (47bdcba)
  • Layouts and access: the scaffold has a root layout (its top bar), and its hello flow goes to docs and back through it. Docs: a Layouts and access guide (coverage, nesting, on, opens, breadcrumbs, for, page or layout), access tests in the testing guide, for in the flows guide, the map's layouts and account view in the UI guide, the manifest's for, siteTree, layouts and accounts, the deprecated page's defineLayout row. Convention skill and planner agent; ROADMAP. MethodBlockOptions and LinkNav exported (00fc88c)
  • Waygraph UI: a layout is one node on the map, with a line to each page its links lead to, and a mark on each page it covers; its panel lists its links (who sees each), actions and pages; a page's panel says its layouts and who can open it. The map shows one account's view (?as=planner): what it isn't given is left out, and says how much. The manifest lists the project's accounts. Tests (1997983)
  • Access: for: [accounts] on Page Blocks, Methods and layout links. waygraph test --flows adds one access test per account (access › , @access): signed in as it, each layout shows exactly the links it's given, and each page it isn't given doesn't open. waygraph check flags a flow as an account that uses a link, Method or page it isn't given. The manifest has each Block's for. Tests (15fe82b)
  • Layouts: defineLayout in a _layout.block.ts covers the pages in its folder and below (or its on), its links are Navs from any page it covers, checked before clicking; to: "parent" goes up the site map, Trait.breadcrumbs checks the trail; the site map moves to the manifest (siteTree). saucedemo's burger menu is a layout (Menu.go.allItems, Menu.go.logout). Tests (008977c)
  • OpenSpec change page-layouts-and-rbac: layouts by folder (_layout.block.ts: links, actions, a Read; nesting; breadcrumbs from the site map) and for: [accounts] on links, actions, pages and Methods, with generated access tests and a check rule (990bb78)
  • A watched demo's window keeps its size when the device changes: the device is drawn inside the page, and the window, which fills the screen, isn't resized or held to 1280x720 (its stage is its measured inner size). A demo with the config's device keeps its window too and shows the device in it from the first step, as a recording does. Test, config reference (0b7281c)

Full changes: v0.16.20...v0.16.21

v0.16.20

Choose a tag to compare

@deviate-dv8 deviate-dv8 released this 10 Nov 09:02
  • 0.16.20 (c0b5cfa)
  • Waygraph UI: the map has a Legend (its bottom bar): what each shape is (a site, a folder, a page), each line (where a page sits by its address, a move), each Block kind on a line, and what's in a page's box. Block kinds have icons (Nav a compass, Method a pointer, API a plug, Expect a badge), on the lines' badges and in the key; the label layout makes room for them. UI guide (585f085)
  • saucedemo's flows in folders: auth/, cart/, checkout/, api/ and (showcase)/ (the feature demos and the smoke flow), and its labels cover them by folder; the quickstart follows. A flow file path with a (group) folder runs (waygraph run src/flows/(showcase)/smoke.flow.ts): a spec's payload is only the ( … ) that ends a segment. Tests, docs (9597e39)
  • Failures read as the step first: "finish-order: check "order-number" didn't pass", then wanted, saw, on (the page) and in (a chain of steps, by its ends: ff-1 → add-to-cart → … → finish-order (9 steps)), one to a line; an expectation's: "confirm-archive: 2 expectations didn't hold" with a line each. --replay of a run that recorded no data for a part (an older run, a test's) plays it with new data and says so, instead of stopping; flow tests now record the data they were seeded with, so Run again replays them. Tests, docs, healer agent (77c3948)
  • saucedemo graph snapshot: InventoryPage sorts where LoggedIn didn't; openspec notes follow the rename (12a77a0)
  • saucedemo: the products page's Checkpoint is InventoryPage (was LoggedIn, a state, not a page), like LoginPage, CartPage and CheckoutInfoPage; the quickstart, tests, docs and examples follow (cd497f3)
  • Waygraph UI: how a flow plays is chosen where it's played: Record video and Show the browser (off: headless) next to Run and Demo on a flow, and next to Run again / Demo again on a run, kept in this browser (the Settings page's Recording is gone). A flow's recent runs have a download for each video. UI guide (54a8b0b)
  • Waygraph UI: the map's Pages tree minimizes to a Pages button (with how many pages the map shows) and opens again; the page panel widens to read a Block's code (remembered); everything clickable shows the hand cursor (Tailwind's base gave buttons, tabs, switches and checkboxes the arrow), and a disabled control shows it can't be clicked. UI guide (e0c9dcd)
  • ROADMAP: a page's read in its Page Block; selectors per device (e754a33)
  • The device flows play on: the config's device ("desktop" by default, "tablet", "mobile", or its parts: { preset: "mobile", orientation: "landscape" }, { width: 1600, height: 900 }) is the browser waygraph test, run and demo start: its size, pixel ratio, phone layout and touch, turned when the orientation says so. A recorded demo keeps its 16:9 stage and shows the device in it; a recorded run records the device's own screen. A flow's map({ device }) replaces map({ viewport }) (a row on the deprecated page) and sizes that flow. One table of device sizes, shared with the demo's ctx.ui.device. Tests, flows, testing and config docs, skills (d94149a)
  • Labels group flows: the config's labels name each label's flows, by a glob over their files or a flow's export name (labels: { auth: ["src/flows/auth/**", "logoutFlow"] }). waygraph test --flows --label auth[,smoke] runs only those (each flow's test is tagged @auth, so Playwright's UI mode and reports filter by it too); waygraph list shows each flow's labels and --label keeps one; the manifest carries them; waygraph check warns about a label that covers no flow; Waygraph UI's Flows page shows them as badges and filters by one. saucedemo has auth and checkout. Tests, testing guide, config and CLI reference, usage, convention skill (67a5957)
  • A demo's overlay stays put between steps on one screen. A step's screenshot no longer hides the overlay to take the picture (that made the title, panel and caption blink on screen and in recordings): in a demo it takes the page as it is and doesn't replace the page's look on the map. The outcome card stays until a step replaces it, in place, instead of going at each step's start and sliding in again. After a page load the overlay paints again at once, without its slide-in and fade-in. demo.overlay leaves parts out: { banner, panel, checks, todos }, each on unless false; without the panel the demo moves on by itself and slides show as captions, and without checks there are no rings on what was checked and no outcome card. WAYGRAPH_OVERLAY_TRACE=1 logs each part showing and going, and how often each blinked. Tests, demo guide, config reference (2e19c9a)

Full changes: v0.16.19...v0.16.20

v0.16.19

Choose a tag to compare

@deviate-dv8 deviate-dv8 released this 10 Nov 05:26
  • 0.16.19 (b9b18e6)
  • waygraph install sets up what the project's config requires, on this machine, after npm install: Chromium and every browser its playwright section names (with the project's own Playwright, never removing another project's browsers), its browser extensions, its demo's voice (Kokoro's environment and model), and what those read, listed in .env.example and .env. What it can't install (ffmpeg for a voice-over, a voice whose setup failed) is named at the end, after the rest, and it exits 1. It does only what's missing; --update fetches everything again, --with-deps adds the browsers' system packages. Replaces waygraph extensions install (a row on the deprecated page). init, the scaffold, the quickstart, the README, saucedemo and the CI recipe say npx waygraph install; Waygraph UI's Project page has it as a button. Tests, project guide (a new machine, a new teammate), CLI reference, usage. And a lint fix in a Waygraph UI test (c4f887f)
  • waygraph extensions install lists what it sets up can read in the project's .env.example and .env (made when missing): blank and commented under a header (# OPENAI_API_KEY= for openAIVoice(), # WAYGRAPH_CACHE_DIR= for Kokoro and browser extensions); a variable a file already names is left as it is, so a second install adds nothing. saucedemo and the quickstart keep .env files out of git too. Test, config reference, demo guide (502ffe9)
  • The scaffold has a .env.example: what a project reads from .env (BASE_URL, WAYGRAPH_MAIL_URL, OPENAI_API_KEY for a voice), each commented out with what it's for. Its .gitignore keeps every .env file but that one out of git. init names both from their dotless template files. Test, config reference (6bc8deb)
  • The voice is in the config: saucedemo's demo speaks with kokoroVoice() (steps too), and the scaffold shows the line. A machine without it records silent and says once to run waygraph extensions install. Each waygraph pins the Kokoro it sets up (kokoro-onnx and soundfile versions, the model release), stamped in installed.json: after an upgrade that moves it, a recording says it's another version, and extensions install replaces it (a new environment, the new model, the old one removed). Demo guide (where it's stored, not set up, a new version), tests (8bcd11e)
  • Demos speak with Kokoro: kokoroVoice() is a natural local voice (af_heart by default; voice, speed, lang), its model loaded once in one Python process kept for the recording. It's heavy, so it isn't part of waygraph's install: waygraph extensions install sets it up once per machine in waygraph's cache (a Python environment through uv when there is one, kokoro-onnx, and the model), as it does browser extensions; without it, a recording says to run that. Lines get a breath between them, and with steps: true the steps' descriptions are made while the first steps play. Tests, demo guide, CLI reference, usage (61df26e)
  • Demos can speak: demo.voice gives a recorded demo (--video) a voice-over. Each new caption and slide is spoken as it shows (and with steps: true, each step's description), one line at a time; auto-advance waits for a line to end, so the voice is never cut off. The recording gets the speech as its audio track (ffmpeg) and its subtitles beside it (
  • Playwright no longer runs the node:test unit files: the local project's testIgnore replaced the top-level one, so tests/unit was imported into the workers, where video-dir's HOME change made later tests miss the browser (d1b6e39)
  • saucedemo: its account keeps its session 9 minutes (ttl), under Sauce Demo's 10, so later runs and test workers reuse it (13edeae)
  • Accounts can say how long a session lasts: account(name, { signIn, ttl: "15m" }) ("30s", "2h", "1d", or ms). A session older than its ttl signs in again; one still good is saved (.waygraph/sessions/, WAYGRAPH_SESSIONS; one file per account, site and person, readable only by its owner), so later runs and every test worker start signed in until it runs out. Without a ttl a session lasts the process and is never saved. --fresh-sessions (run, demo, test) signs every account in again and saves the new sessions. Quickstart ignores .waygraph/. Tests, flows guide, CLI reference, env reference, convention skill, ROADMAP (c6ca2cc)
  • The manifest links each Block to its code and selectors: source (the lines that define it, for Read Blocks and flows too), checks (its precondition and verify Traits as data, "dynamic" when a function builds them) and selectors (the selector-file entries its definition reads), plus every entry of the project's selector files (_sel.ts, *.sel.ts), read from the source. Waygraph UI: a map page's panel puts what matters first (what the page shows, what you can do there, the ways in and out, what's expected, its selectors; its flows last, failing first) in sections with counts, and opens a Block for its checks, selectors and code; the Blocks page opens a Block the same way and lists every selector with the Blocks that read it; the Flows page is a list by folder, failing first, filtered by outcome. Pages load on hover and show a stale manifest while a new one is read; run logs are parsed again only when they change. A run's video plays on its page and downloads, its trace downloads, and Settings can record a video for plays. Docs (UI guide, manifest reference), ROADMAP, tests (c42df1d)
  • A read check the page doesn't show the key for says what its namespace showed instead (no value for login.sent; the page shows login.emailError "Could not send the link..."), not only that nothing was read. Reads guide, test (70ff282)

Full changes: v0.16.18...v0.16.19

v0.16.18

Choose a tag to compare

@deviate-dv8 deviate-dv8 released this 09 Nov 22:38
  • 0.16.18 (62fa4f4)
  • Waygraph UI: a page on the map lists what it shows, the fields its Read Blocks read by namespace, the yes/no ones highlighted as the states the page can be in. Each box is as tall as its list (measured once drawn), and the layout sizes each column and row to its boxes and moves a subtree down when its page is taller than its children, so no box covers another. UI guide (f1fd1f7)
  • Accounts say who their person is: account(name, { signIn, mem }) sets the person's data (an email for a magic link) right before signing in, so a flow as the account needs nothing more and an earlier flow's person doesn't carry over; its keys aren't asked of flows as it. Waygraph loads src/accounts/ (runs, demos, waygraph test), so a sign-in flow that is one account's, played on its own (waygraph demo loginLeadershipFlow, or Run in Waygraph UI), signs in as that person without --data (a --data value still wins). MemPage.keys(). Tests, flows guide, convention skill, planner agent (0d7d8d9)
  • Waygraph UI: the sidebar's pages can be hidden (Settings, kept in the browser; a hidden page still opens by its address and shows while you're on it). The map makes room for its labels: lines into a page put their Blocks beside it (before it from an earlier column, after it from its own), stacked when several meet there, and the layout widens each gap and row to fit them, so a label never covers a box or another label. Icons named in .ts files are bundled too. UI guide (378a2d0)
  • Page objects and waygraph: a docs page (what waygraph adds to a page object model, part for part; measured side by side; adopting it one flow at a time with Blocks that call existing page objects) and examples/pom-vs-waygraph, the same Sauce Demo checkout as page objects, as waygraph, and as Blocks wrapping the page objects, played against UI changes (npm run compare). A failure inside a step's act names its step (act of "sign-in" failed: ...) and stays the error it was; the run log's step:error keeps the error's own text. Tests, checks guide, README (2eecd92)
  • A Checkpoint is a page, in the examples and the scaffold. saucedemo and the quickstart drop ItemInCart: adding or removing an item (one, or all) leaves you on the inventory, and its verify checks what the inventory shows (each item's inCart) instead of resolving to another Checkpoint. The scaffold drops ItemInCart, CartEmpty, CanAddItem and HomeVerified: add, remove and clear stay on Home and check home.items / home.cartCount; the verification link lands on Home with home.verified; the item-added expectation is HomeRead.cartCount.is(1) in place. Guides (blocks, flows, reads, mail, how it works, home), convention skill, tests (3ec9aa5)
  • Reads guide: nothing imports a Read Block; run, demo, test and the live sessions load them (7fdec95)
  • waygraph test loads the project's Read Blocks, as run and demo do: a verify or expect that checks what a page shows (Key.is / passes) read nothing in a spec or a flow test unless its flow imported the Read Block file. Test (a flow test whose verify reads through a Read Block no flow imports) (7d1414e)
  • waygraph check names a Checkpoint that is a state of a page: nothing starts from it, and it has no address of its own and only Methods land on it (an item in the cart, a link sent), or only another page's address (an alert on the sign-in page). What changed on a page is a Read Block's field, checked in verify or expected. Doctrine (a Checkpoint is a page), blocks guide, convention skill, tests (a5ac44b)
  • Waygraph UI: a Project page. The project's waygraph commands as buttons (check, validate, typecheck, map, graph, list, nav, manifest, test, test --flows, upgrade, extensions install, upgrade --skills and the codemods, which ask first), run with its own waygraph, one at a time, their output as they print; Stop ends one and what it started, and it says stopped. And the project's config: what it resolves to, or the file as written. waygraph manifest reports config: the config file and its resolved values as JSON (a function as a word). Tests, docs (UI guide, manifest), ROADMAP (224cef8)
  • Waygraph UI: a Blocks page. Every Block by its folder (kind, route, what it requires and expects, its file, the flows that use it), found by name, page or file and filtered by kind; from the newest runs, how often it ran and failed, its mean time, and what it did to the address: navigates (its step ended on another path: a redirect, a single-page app's routing) or changes the address (same page, the query or hash changed: a tab, a filter). Read Blocks with their fields' types, and mem keys with who requires each and the newest run's value. Tests, UI guide (f438f53)
  • Waygraph UI: the map has a page tree beside it, the site map as folders (sites, path folders, pages with their addresses): check or uncheck to show or hide a part, only to keep one branch (just the equipment pages), All / None, find by name or path; the choice is kept per project in the browser, and the map lays out and fits what's shown, beside the tree. waygraph's Start isn't a page on the map. UI guide (978f914)

Full changes: v0.16.17...v0.16.18

v0.16.17

Choose a tag to compare

@deviate-dv8 deviate-dv8 released this 09 Nov 08:59
  • 0.16.17 (aeee2e9)
  • waygraph check: two false positives gone. A Block a flow names only in an expect: [...] (a step's, or a Block's own, per outcome) is not an orphan (a project with its expectations in QA flows had 110 orphans, 14 real). The constant test data warning is for a Block that makes something (named like a create, or an API Block that POSTs; GET reads, PUT/PATCH/DELETE change what's there) when none of its keys is new every run: a sign-in token next to a name from unique is fine (it warned about every API Block's token). An API Block records its method. Tests, docs (data, blocks) (f2c685d)
  • --replay makes a per-run value new again: a key whose mem stub gives a different value each run (a name from unique) gets a fresh one, so a replay doesn't make the same machine or signup twice and fail on the app refusing it (Waygraph UI's Run again / Demo again replay). What --data gave and stubs that are always the same are replayed as before. Test, docs (data, UI, run log, CLI), skill, --replay help (9d0de45)

Full changes: v0.16.16...v0.16.17

v0.16.16

Choose a tag to compare

@deviate-dv8 deviate-dv8 released this 09 Nov 08:19
  • 0.16.16. The UI guide says the map's addresses and page screenshots need 0.16.16 or later in the project (98037d9)
  • Waygraph UI: the map reads like a site map, one level per part of the address. A path segment no page has is a folder (auth/, platform/, then plant/), so /platform/plant/lines sits three levels in instead of every page hanging off its site on one line; a folder's children follow the journey. The site map is worked out on the server (services/site_map.ts) and passed to the map page. Tests, UI guide (676973a)
  • Effect Blocks are removed: an Effect was a Method that also listed the rows it can act on, and a Method lists them the same way (requires + instanceOptions; waygraph auto still offers one menu row each). defineEffectBlock, EffectBlock, EffectExtras and the effect kind are gone; waygraph upgrade --codemod effect makes them Methods, imports each name once, and renames *.effect.block.ts to *.method.block.ts with the imports that name them. The saucedemo example, the quickstart and the scaffold are converted by it (their graph is unchanged). Waygraph UI shows an old run's effect step as a Method. Docs (blocks, how it works, flows, project, saucedemo, pilot, agents, map, UI, README), skills and agents, the removed page (0.16.16), tests (bdfa2fb)
  • Waygraph UI: a flow opens in Playwright UI on its own (Playwright UI next to Run and Demo: the Playwright page with only that flow's test, -g on its title; Show all flows goes back to every one; another flow restarts it over that one). Header spacing. UI guide (ad47395)
  • Waygraph UI: a Playwright page runs Playwright's UI mode over the project's flows inside the app (waygraph test --flows on a free port, in a frame; Stop ends it and its browsers, so does the app's shutdown), and a Settings page (the gear) with Demo: Auto-advance, on by default: a demo started from the UI passes --auto-next or --no-auto-next. The waygraph launcher passes SIGTERM and SIGHUP on to the CLI (a kill left a UI server or a demo's browser running) and waits for it on Ctrl-C. Tests, UI guide, ROADMAP (96586af)
  • Waygraph UI: a page's flows read plainly: how many land, may land and act there, then how their newest runs went (passed, failed, stopped, never run); listed in that order. A run with no flow named (a test calling flow.run) counts for the flow whose steps it played. waygraph test --flows names each flow in its run log. Tests, UI guide, run log reference (1e9944a)
  • Waygraph UI: each page on the map says how many flows pass through it and how many failed their newest run; its panel lists them, each with how it gets there (lands, may land: a step with several outcomes that ends the flow, or acts there) and its newest run's outcome, linked. A flow's newest run settles where a step with several outcomes landed. A run of one flow plays again as a run or as a demo (Run again, Demo again), with the mem it was seeded with. Tests, UI guide (03191de)
  • Demo: a step that loads a new page partway (a login landing on another document) keeps its collapsed panel with the steps' progress; the running panel is a piece of the overlay layer and is painted again on the new page. The rings after a step skip at once what its checks saw before the page changed, instead of waiting 30s for each (a login step stalled a minute). Test, demo guide (a5c6fce)
  • Waygraph UI: a page's Shows lists what its Read Blocks read as a tree, grouped by namespace: each field with its type as a badge (text, number, yes/no in their own colours), a list's item fields nested under it, instead of the raw JSON shape (48e2f6c)
  • Waygraph UI map: each Block on a line is a badge with its whole name, in its kind's colour (Nav blue, Method grey, Effect amber, API green), with a key in the bottom bar; no more names cut short or folded into +N. A line into the next column ends its badges at its arrowhead, over the boxes, on an opaque background; columns sit further apart to give them room. Kind colours live in one place (lib/kinds.ts) (f9fffd6)
  • Screenshots, the map as a flowchart, and the demo's finish card. A Block's screenshot option (true, or { fullPage: true }) takes a picture as the last thing in its step; on a Page Block, whenever a step lands on its page. The run log keeps each with its run (runs//-.png, a run:artifact naming the step and the page) and each page's newest (screenshots/.png); the overlay is left out of the picture, and a screenshot never fails a step. The saucedemo example and the scaffold's pages take them. Waygraph UI shows a page's newest on the map and in its panel, and each step's on the run. The map reads left to right by default (a run of pages in a grid; a switch lays it out top down), in squared lines, each in its own lane, with moves within a depth bracketed past the boxes; flowchart shapes (terminator for a site or a step to a page, process, predefined process for a fast-forward, input/output for an API step); panels with a visible outline. The demo ends on a finish card over a veil: Finished, Finished as expected, or Stopped with where and why, the title and steps and time, held a moment so a recording ends on it. npm run ui / ui:dev run this checkout's Waygraph UI on saucedemo. Tests, stories, docs (blocks, demo, UI, run log), skill (d1f64f1)
  • waygraph ui serves on 9294 by default ("WAYG" on a phone keypad), not 3333, which AdonisJS and other dev servers use; still the next free port when it's taken. The UI's dev .env, CI, help and docs follow (e2fed26)
  • Waygraph UI: the map is a site map, and every page and step shows its address. Each site sits at the top (the base url's host, and every other site a page's address names), its pages below by their paths, dashed and labelled with the Navs that open them; a page with no address hangs under the page whose move reaches it; rows follow the order the flows visit pages. Pages, flow steps and run steps show their url (a run step: where it ended; the panel links it). The manifest gains each Nav or Page Block's url (a url built from mem as a pattern, /requests/:id), pageUrls (by Checkpoint, from Navs and the Trait.url its Blocks verify) and the project's baseUrl; a run's step:end carries the page's url. A CHROME_PATH that doesn't exist is ignored without a word. Tests, docs (UI guide, run log and manifest, config) (377ef8f)
  • Docs: Waygraph UI is marked beta (guide, sidebar, README), says it comes with waygraph 0.16.13+ on Node 24 and runs the project's own waygraph, and shows up where a new user looks: the quick start and the home page (npx waygraph ui) and waygraph init's command list (591bf02)

Full changes: v0.16.15...v0.16.16