waygraph 0.15.24 → 0.15.26

package/dist/engine.d.ts

@@ -1,1224 +1,11 @@
-import type { BrowserContext, BrowserType, Page, Locator } from "@playwright/test";
-import type { Block, Checkpoint, Instruction, DefinedBlock, ActionPage, WaygraphHighlight } from "./types.js";
-import { MemPage } from "./mem-page.js";
-import type { MemKey } from "./mem-page.js";
-import type { Trait } from "./trait.js";
-import { type HighlightStyleDefaults, type DemoPace } from "./highlights.js";
-/**
- * Checks `block.requires` against `mem` and throws, naming every missing key at
- * once, if any are unset. `connect()` unions each Block's `requires` into the
- * composed Block, so calling this on a `defineFlow`-built Flow's entry - which
- * `runGraph` does automatically, before opening a tab - covers every Block in
- * that flow. It does not see Blocks only reachable through `branch()` routing,
- * since those depend on a runtime decision that hasn't happened yet.
- */
-export declare function preflight(mem: MemPage, block: Block<any, any>): void;
-/**
- * A cross-cutting, automatically-enforced verify - the real engine
- * primitive behind "persistent UI" (a sidebar, a header, anything that's
- * supposed to be present on many/most Checkpoints, not just one page's own
- * Block). Deliberately NOT tied to any folder convention - `appliesTo`
- * matches by Checkpoint tag, explicitly, so this works the same whether a
- * project uses the Waygraph Map folder convention or the older freeform
- * "manual mode" layout real production consumers (pia-waygraph,
- * zsign-atomic-waygraph) already use - registering a Layout with an Engine
- * is the only requirement, folder structure is irrelevant to it.
- *
- * Not a Block: no `act`/`resolve`/Checkpoint of its own, never a graph
- * node - it only ever adds extra `verify` Traits to Checkpoints something
- * else already resolved to, the same way `runVerify` already runs after
- * any Block's own `resolve()` (see `runGraph`'s own verify step, just
- * below) - a Layout is that mechanism made reusable across many
- * Checkpoints instead of hand-repeated per Block.
- */
-export interface Layout {
-    name: string;
-    description?: string;
-    appliesTo: (tag: string) => boolean;
-    /** Function form gets the full resolved Checkpoint, same shape `runVerify`/a Block's own `verify` already use - not just the tag. */
-    verify: Trait[] | ((out: Checkpoint<string>) => Trait[]);
-}
-export interface LayoutOptions {
-    name: string;
-    description?: string;
-    /** A fixed tag list, or a predicate for open-ended matching (e.g. a naming pattern). */
-    appliesTo: readonly string[] | ((tag: string) => boolean);
-    verify: Trait[] | ((out: Checkpoint<string>) => Trait[]);
-}
-/**
- * @example
- * const AppShellLayout = defineLayout({
- *   name: "app-shell",
- *   appliesTo: ["AppHome", "Chats", "Notifications", "Settings"],
- *   verify: [Trait.visible(SidebarSel.root)],
- * });
- * const engine = new Engine({ layouts: [AppShellLayout] });
- * // Now every Block resolving to one of those four Checkpoints, in any
- * // Flow this engine defines, also gets AppShellLayout's own verify run
- * // automatically - a page that silently drops the sidebar fails loud,
- * // even though no individual Block's own `verify` mentions it.
- */
-export declare function defineLayout(options: LayoutOptions): Layout;
-/**
- * Runs `entry` against a fresh tab and returns the resulting terminal Checkpoint.
- * The engine owns the tab's lifecycle, not any individual Block: the tab is
- * created before the first `act` runs and closed in `finally`, so it closes even
- * if a step throws.
- *
- * After each Block resolves, its `next` (if any, from `branch()`) is followed to
- * the following Block, in the same tab - a Block with no `next` runs exactly once,
- * unchanged from before `branch()` existed. `next` returning the same Block is a
- * self-loop; `maxSteps` bounds the loop so a routing bug fails loud instead of
- * hanging.
- *
- * `terminals`, if given, is a sanity check: the Checkpoint the run stops on must be
- * one of the tags the caller actually expects, or the run fails loud instead of
- * silently returning an unexpected result. Omit it when there is only ever one
- * reachable outcome by construction (as with a `defineFlow`-built Flow, which has
- * no routing at all) - there is nothing to validate against.
- */
-export declare function runGraph<TOut extends Checkpoint<string>>(entry: Block<Checkpoint<"__start__">, TOut>, terminals: ReadonlySet<string> | undefined, context: BrowserContext, mem: MemPage, maxSteps?: number, options?: RunGraphOptions): Promise<TOut>;
-/** Options for `runGraph`'s trailing `options` arg and for {@link Flow.run}'s `options` overload. */
-export interface RunGraphOptions {
-    /**
-     * Drive this already-open page instead of opening a new one via
-     * `context.newPage()`. Lets a run continue on a tab the caller already
-     * has open (e.g. one that's already logged in), instead of every run
-     * being forced to start its own fresh tab and lose access to whatever was
-     * already there.
-     */
-    page?: Page;
-    /**
-     * `Flow.run` defaults this to `true` only when it opened the page itself
-     * (no `page` given) - matching every call from before this option
-     * existed. If you pass your own `page`, it defaults to `false` instead:
-     * a page you opened is yours to close, not this run's to close out from
-     * under you. Either way an explicit value here always wins. `runGraph`
-     * itself has no such page-aware default (its caller already decided
-     * `page` and `closeOnFinish` together) - it just does what you ask.
-     */
-    closeOnFinish?: boolean;
-    /**
-     * Layouts (see {@link defineLayout}) whose `verify` runs automatically
-     * after any Block in this run resolves to a Checkpoint they apply to -
-     * `Flow.run` threads this in from `EngineConfig.layouts` by default; pass
-     * it directly here to call `runGraph` standalone (outside a `Flow`) with
-     * layouts still enforced.
-     */
-    layouts?: readonly Layout[];
-}
-/**
- * Drives a genuinely separate second tab through its own Block/Flow, in the
- * same browser context an existing `page` already belongs to - the primitive
- * `observe()` is specifically allowed to reach for (see {@link Instruction.observe}),
- * since `act`/`resolve` can't touch `page.context()` at all. A thin, named
- * wrapper around `runGraph` (which already opens its own page from whatever
- * context it's given) rather than a new mechanism - the point is making the
- * pattern discoverable and giving it a real name, not inventing new tab-lifecycle
- * logic. The spawned tab is closed (by `runGraph`'s own `finally`) before this
- * resolves; the original `page` is never touched.
- * @example
- * async observe(page, mem) {
- *   const receipt = await spawnTab(EmailReceiptFlow, page, mem);
- *   mem.set(ReceiptCode, receipt.__state);
- * }
- */
-export declare function spawnTab<TOut extends Checkpoint<string>>(entry: Block<Checkpoint<"__start__">, TOut>, page: Page, mem: MemPage, maxSteps?: number): Promise<TOut>;
-/**
- * Wraps one `act()` interaction with a caption and highlight, for a Block
- * author who wants to explicitly narrate a specific step rather than rely
- * on the generic per-fill/per-click narration `waygraph chain
- * WAYGRAPH_STEP=1` already does automatically -
- * `await narrate(submitButton, "confirms the order", () => submitButton.click())`
- * reads at the call site instead of being inferred.
- *
- * A true no-op everywhere except inside a `WAYGRAPH_STEP=1` run: it checks
- * for a `window.__wgPositionRing` hook the step-mode overlay installs on
- * the page before doing anything, so a headless/CI/automated run (nobody
- * watching, per-character delays and highlight pauses would just be wasted
- * time) pays zero extra cost - not even the boundingBox() lookup runs. The
- * `action` itself always runs regardless; only the narration is
- * conditional.
- * @example await narrate(submitButton, "confirms the order", () => submitButton.click())
- */
-export declare function narrate<T>(locator: Locator, caption: string, action: () => Promise<T>): Promise<T>;
-/** Reserved markers bookending a `defineFlow([start, ...blocks, end])` call. */
-export declare const start: unique symbol;
-export declare const end: unique symbol;
-type StartMarker = typeof start;
-type EndMarker = typeof end;
-/**
- * A composed, runnable flow. Always begins from Checkpoint<"__start__">, same as
- * runGraph's `entry`. `run(context, mem)` uses a context you already have (the
- * usual case inside a `@playwright/test` file, via its `context` fixture) -
- * there's no browser for this Flow to launch, so no config to pass. `run(mem,
- * config?)` - no context - has the Engine launch and own its own browser for
- * this one run instead, and closes it in `finally`; use this outside a
- * Playwright test file, or when a flow genuinely needs its own browser instance
- * rather than sharing the test's. `config` here overrides, per key, whatever
- * `new Engine(...)` was constructed with - so one flow (module-level, imported
- * by many specs) can still have every run choose its own `headless`/`slowMo`
- * rather than being stuck with whatever the flow's own file happened to set.
- *
- * `withBlockVerify`/`modBlockVerify` do what {@link withVerify}/{@link modVerify}
- * do for a single Block, one level up - a spec that only imports the finished
- * Flow (not necessarily the individual Blocks it was built from) can still
- * patch one Block's verify for just that call, without editing the flow's own
- * file or hand-rebuilding its Block list. Addressed the same three ways
- * `modVerify` already addresses a Trait - the Block reference itself
- * (`LoginBlock`, imported like any other Block; typo-proof, refactor-safe,
- * jump-to-definition works), a plain string name, or a numeric index into this
- * Flow's Block list (position between `start`/`end`, 0-based) for a spec that
- * genuinely doesn't have the Block imported and doesn't want to spell its
- * name. A reference or string resolves by `.name` under the hood (a Block's
- * own stable identity in this codebase, same as every error message elsewhere
- * in this file already uses) rather than object identity - it stays
- * resolvable even after an earlier patch already swapped that slot for a new
- * object, since the name survives every `withVerify`/`modVerify` in the
- * chain; an index is checked fresh against this Flow's current Block list
- * each call, so it's still correct after a patch too. Returns a new Flow -
- * the original is untouched, same as every other decorator in this module.
- */
-/**
- * One Block's identity as exposed by graph introspection - {@link Flow.blocks},
- * {@link ComposedBlock.steps} - without needing to execute anything. Does not
- * include the Block's literal Checkpoint `In`/`Out` tags: those are TypeScript
- * literal types, erased at runtime, and can only be recovered by a build-time
- * static-analysis tool reading the source's own type annotations - see the
- * `graph-visualization` openspec change for that piece.
- */
-export interface BlockInfo {
-    name: string;
-    /** `branch()`'s routing table, if this Block has one - see {@link Block.routes}. */
-    routes?: Readonly<Record<string, string | null>>;
-    /**
-     * True when {@link chainFlow} inserted a session-reset boundary
-     * immediately before this Block - i.e. this is the first Block of a
-     * sub-flow that was wrapped in {@link withSessionReset}, and it isn't
-     * the very first sub-flow in the chain. Absent (not just false) from
-     * `Flow.blocks()` on an ordinary, non-chained Flow.
-     */
-    resetSessionBefore?: boolean;
-    /**
-     * The actual Block, re-runnable on its own via
-     * `engine.defineFlow([start, info.block, end])` - e.g. step-through
-     * tooling that runs a Flow's Blocks one at a time. Introspection that only
-     * wants to read the shape (a visualizer) can ignore this and use `name`/
-     * `routes` alone.
-     */
-    block: Block<any, any>;
-}
-export interface Flow<Out extends Checkpoint<string>> {
-    /**
-     * True once this Flow has been wrapped in {@link withSessionReset} - a
-     * hint for `chainFlow`, not something `run()` itself checks: it marks
-     * this Flow as one that expects to start from a genuinely fresh,
-     * unauthenticated browser state (e.g. a login flow meant to be
-     * re-entered later in a longer chain). `chainFlow` clears cookies and
-     * storage right before this Flow's first Block runs, but only when this
-     * Flow isn't the very first thing in the chain (nothing to reset yet).
-     */
-    readonly resetSession: boolean;
-    /**
-     * Set once this Flow has been wrapped in {@link withTitle} - a display
-     * hint for a step-through overlay/showcase (e.g. "Ticket #123"), not
-     * something `run()` itself uses.
-     */
-    readonly title?: string;
-    /**
-     * Set once this Flow has been wrapped in {@link withExpectedFailure} - a
-     * display hint for a step-through overlay: this Flow is DESIGNED to throw
-     * (e.g. a blocked user's login attempt genuinely failing), not a bug in
-     * the demo itself. `run()` never reads this - the Flow still throws
-     * exactly as it would otherwise; only the overlay's error panel reads it,
-     * to show an informational "this is the point" panel instead of an
-     * alarming one indistinguishable from a real break.
-     */
-    readonly expectedFailureReason?: string;
-    /**
-     * Set once this Flow has been wrapped in {@link withHighlightFixtures} -
-     * demo narration overrides (unlimited purposes on `.flow.ts`) keyed by
-     * block.name. `run()` never reads this; step/`demo` merges onto block stubs.
-     */
-    readonly highlightFixtures?: import("./highlights.js").HighlightFixtureMap;
-    /**
-     * Demo pacing for this Flow's episode (`withDemoPace`).
-     * `run()` ignores; step/demo applies per Block in the episode.
-     */
-    readonly demoPace?: import("./highlights.js").DemoPace;
-    /**
-     * Default highlight size/weight/tone for this Flow's episode (`withHighlightStyle`).
-     * Per-slot stub/fixture values win. `run()` ignores.
-     */
-    readonly highlightStyle?: import("./highlights.js").HighlightStyleDefaults;
-    /**
-     * Set once this Flow has been wrapped in {@link withMemStub} - opts into
-     * auto-filling `requires` keys with registered fake values
-     * (`registerMemStub`, `src/mem-stub.ts`) instead of failing preflight when
-     * the caller didn't supply them. `run()` never reads this - the CLI's own
-     * `--data`/`--mem-stub` seeding, or a bare-library caller's own explicit
-     * `seedMemStub(mem, flow)` call, is what actually fills mem before `run()`.
-     */
-    readonly memStub?: boolean;
-    /**
-     * This Flow's constituent Blocks, in order between `start`/`end`, as plain
-     * data - for introspection/visualization tools, without running anything.
-     * @example loginFlow.blocks() // [{ name: "login" }, { name: "add-to-cart", routes: {...} }]
-     */
-    blocks(): readonly BlockInfo[];
-    run(context: BrowserContext, mem: MemPage): Promise<Out>;
-    /**
-     * `options.closeOnFinish: false` hands the driven page back instead of
-     * closing it - use this overload (a literal `false`, not a `boolean`) to
-     * get the `{ result, page }` shape typed correctly.
-     * @example const { result, page } = await loginFlow.run(context, mem, { closeOnFinish: false });
-     */
-    run(context: BrowserContext, mem: MemPage, options: RunGraphOptions & {
-        closeOnFinish: false;
-    }): Promise<{
-        result: Out;
-        page: Page;
-    }>;
-    /**
-     * `options.page` drives that already-open page instead of opening a new
-     * one - see {@link RunGraphOptions}.
-     * @example await loginFlow.run(context, mem, { page: existingPage });
-     */
-    run(context: BrowserContext, mem: MemPage, options?: RunGraphOptions): Promise<Out>;
-    run(mem: MemPage, config?: EngineConfig): Promise<Out>;
-    /**
-     * Replaces the given Block's whole verify list, wherever it sits in this
-     * Flow - same rules as {@link withVerify}. Throws if no Block in this Flow
-     * matches.
-     * @example checkoutFlow.withBlockVerify(LoginBlock, [])
-     * @example checkoutFlow.withBlockVerify("login", [])
-     * @example checkoutFlow.withBlockVerify(0, [])
-     */
-    withBlockVerify(block: Block<any, any> | string | number, verify: Trait[] | ((out: any) => Trait[])): Flow<Out>;
-    /**
-     * Replaces one Trait inside the given Block's verify list - same rules as
-     * {@link modVerify}. Throws if no Block in this Flow matches, or if that
-     * Block has no verify trait at the given name/index.
-     * @example checkoutFlow.modBlockVerify(LoginBlock, "url-matches", Trait.url({ pathname: "/inventory.html" }))
-     */
-    modBlockVerify(block: Block<any, any> | string | number, nameOrIndex: string | number, newCheck: Trait["check"] | Trait): Flow<Out>;
-}
-/**
- * Marks a Flow as expecting to start from a genuinely fresh, unauthenticated
- * browser state - e.g. a login flow meant to be re-entered later in a longer
- * showcase. Non-destructive, same pattern as {@link withVerify}: returns a
- * new Flow: the original is untouched, and the flag survives any further
- * `withBlockVerify`/`modBlockVerify` patch applied to the result.
- *
- * By itself this does nothing - `Flow.run()` never reads `resetSession`.
- * It's a hint {@link chainFlow} looks for: right before this Flow's first
- * Block runs (skipped if it's the very first thing in the chain - nothing
- * to reset yet), chainFlow clears cookies and storage so this Flow starts
- * exactly as if a human had opened the app fresh, not wherever the
- * previous Flow in the chain happened to leave the page.
- * @example const loginFlow = withSessionReset(engine.defineFlow([start, LoginBlock, end]));
- */
-export declare function withSessionReset<Out extends Checkpoint<string>>(flow: Flow<Out>): Flow<Out>;
-/**
- * Names a Flow for display - a step-through overlay/showcase (waygraph's
- * `chain --step`) shows this as the running banner while this Flow's own
- * Blocks are executing, instead of one fixed title for the whole run.
- * Non-destructive, same pattern as {@link withSessionReset}.
- * @example const ticket123 = withTitle(loginFlow, "Ticket #123 - Sales rep signs in");
- */
-export declare function withTitle<Out extends Checkpoint<string>>(flow: Flow<Out>, title: string): Flow<Out>;
-/**
- * Opts this Flow into memStub: `requires` keys the caller didn't supply get
- * filled from `registerMemStub`'s registry (`src/mem-stub.ts`) instead of
- * failing preflight, for any key that has a registered fake generator - a
- * required key with no registration still fails exactly as before.
- * Non-destructive, same pattern as {@link withTitle}. `run()` never reads
- * this itself - the CLI's `--data`/`--mem-stub` seeding, or a bare-library
- * caller's own explicit `seedMemStub(mem, flow)` call, does the filling.
- * @example const demoLogin = withMemStub(loginFlow);
- */
-export declare function withMemStub<Out extends Checkpoint<string>>(flow: Flow<Out>): Flow<Out>;
-/**
- * Demo pacing for a whole Flow episode (fast review vs slow gap/wrong walkthrough).
- * Non-destructive. `fastForwardComposeBlock` is always blitz for its own step;
- * use this when an entire episode should be fast or slow.
- * @example withDemoPace(withTitle(gapFlow, "Episode 2 - gaps"), "slow")
- * @example withDemoPace(happyFlow, 0.5)  // 2x faster than normal
- * @example withDemoPace(gapFlow, 2.5)    // 2.5x slower
- * @example withDemoPace(gapFlow, 4500)   // absolute ~4.5s gates/dwells
- */
-export declare function withDemoPace<Out extends Checkpoint<string>>(flow: Flow<Out>, pace: DemoPace): Flow<Out>;
-/**
- * Default highlight look for a Flow episode (size / weight / optional tone).
- * Per-slot stub or {@link withHighlightFixtures} values win when set.
- * @example withHighlightStyle(withDemoPace(gapFlow, "slow"), { size: "lg", weight: "bold" })
- */
-export declare function withHighlightStyle<Out extends Checkpoint<string>>(flow: Flow<Out>, style: HighlightStyleDefaults): Flow<Out>;
-/**
- * Demo pacing for one Block or compose unit (not FF - use fastForwardComposeBlock for blitz).
- * @example withBlockPace(composeBlock("gap-review", [...]), "slow")
- */
-export declare function withBlockPace<In extends Checkpoint<string>, Out extends Checkpoint<string>>(block: Block<In, Out>, pace: DemoPace): Block<In, Out>;
-/**
- * Marks a Flow as one that's SUPPOSED to throw - e.g. a locked-out user's
- * login attempt genuinely failing, demonstrating the app's own real
- * behavior rather than a bug in the demo. Non-destructive, same pattern as
- * {@link withTitle}.
- *
- * By itself this changes nothing about how the Flow runs - it still throws
- * Marks a Flow whose last step is an intentional product failure (demo overlay).
- * Step mode shows stubOnError rings + an amber "expected outcome" panel when:
- * - the last block **throws**, or
- * - the last block **succeeds** on the fail branch (e.g. LoginPage + error banner
- *   after submit-login branched instead of throwing).
- * Headless `run()` is unchanged - branching success returns the checkpoint.
- * @example const viewerBlockedFlow = withExpectedFailure(
- *   engine.defineFlow([start, NavLoginBlock, SubmitLoginActionBlock, end]),
- *   "locked_out_user stays on LoginPage with the error banner - working as intended.",
- * );
- */
-export declare function withExpectedFailure<Out extends Checkpoint<string>>(flow: Flow<Out>, reason: string): Flow<Out>;
-/**
- * Attaches demo highlight fixtures to a Flow - unlimited purposes on `.flow.ts`
- * (AC copy, BUG/GATE tags, detail) merged onto each block's stubBefore/stubAfter/
- * stubOnError slots. Non-destructive, same pattern as {@link withTitle}.
- * Demo/`chain --step` reads `flow.highlightFixtures`; `run()` ignores it.
- * @example withHighlightFixtures(issueFlow, { "submit-login": { stubBefore: { email: { label: "AC-1" } } } })
- */
-export declare function withHighlightFixtures<Out extends Checkpoint<string>>(flow: Flow<Out>, fixtures: import("./highlights.js").HighlightFixtureMap): Flow<Out>;
-/**
- * Runs several complete, independent Flows one after another, reusing the
- * same page/context/mem in order - each remains its own validated
- * start-to-end unit (a Flow's own `[start, ...blocks, end]` contract is
- * untouched), this only sequences whole Flows. Deliberately NOT the same
- * thing as {@link composeBlock}: composeBlock nests several Blocks into
- * one Block that can drop back into another `defineFlow([...])` - a
- * chainFlow result is a Flow, but not meant to be nested inside another
- * Flow's own Block list. Recursive nesting stays composeBlock's job alone;
- * chainFlow is a flat, one-level sequencing of complete showcases (e.g.
- * "ticket #123 end to end, then ticket #456 end to end").
- *
- * A sub-flow wrapped in {@link withSessionReset} gets its cookies/storage
- * cleared right before it runs (skipped for the very first flow in the
- * chain - nothing to reset yet). The combined result is whatever the LAST
- * flow resolved to.
- * @example chainFlow(ticket123Flow, ticket456Flow).run(context, mem)
- */
-export declare function chainFlow(...flows: readonly Flow<any>[]): Flow<any>;
-/**
- * A Block guaranteed to have `withStepVerify`/`modStepVerify` attached - what
- * {@link composeBlock} returns. Extends plain `Block`, so it drops straight into
- * `defineFlow([start, ..., composed, ..., end])` like any other Block; no special
- * casing needed anywhere that only expects a `Block`.
- */
-export interface ComposedBlock<In extends Checkpoint<string>, Out extends Checkpoint<string>> extends Block<In, Out> {
-    /**
-     * This composed Block's constituent steps, in order, as plain data - same
-     * shape and purpose as {@link Flow.blocks}.
-     * @example GovFormBlock.steps() // [{ name: "step-1-name" }, { name: "step-2-address" }, ...]
-     */
-    steps(): readonly BlockInfo[];
-    /**
-     * Replaces one step's whole verify list, wherever it sits in this composed
-     * Block - same rules as {@link withVerify}. Throws if no step matches.
-     * @example GovFormBlock.withStepVerify("step-2-address", [])
-     */
-    withStepVerify(step: Block<any, any> | string | number, verify: Trait[] | ((out: any) => Trait[])): ComposedBlock<In, Out>;
-    /**
-     * Replaces one Trait inside one step's verify list - same rules as
-     * {@link modVerify}. Throws if no step matches, or that step has no verify
-     * trait at the given name/index.
-     * @example GovFormBlock.modStepVerify("step-2-address", "zip-visible", Trait.visible("#zip-confirmed"))
-     */
-    modStepVerify(step: Block<any, any> | string | number, nameOrIndex: string | number, newCheck: Trait["check"] | Trait): ComposedBlock<In, Out>;
-}
-/**
- * Chains several Blocks into one named, exported unit - what a naturally
- * multi-step feature (a stepper form with several pages, say) wants instead of
- * either one giant Block with no per-step confirmation, or several separately
- * exported Blocks the caller has to wire together by hand every time. Each
- * step keeps its own real `act`/`resolve`/`verify`, chained the same way
- * `connect()` already chains any two Blocks - `composeBlock` is not a new
- * execution mechanism, just `connect()` reduced over the list plus a name and
- * the same step-list closure `Flow` already keeps for its own Block list, so
- * `withStepVerify`/`modStepVerify` can patch one step from outside without the
- * caller needing to hand-rebuild the chain. Resolution is by `.name`, not
- * object identity, so a step reference stays valid even after an earlier patch
- * swapped that slot for a new object - see {@link Flow.withBlockVerify} for
- * the identical guarantee one level up. Each call returns a new composed
- * Block; the original is untouched.
- * @example composeBlock("gov-form", [step1, step2, step3, step4])
- */
-export declare function composeBlock<In extends Checkpoint<string>, Out extends Checkpoint<string>>(name: string, steps: readonly [Block<In, Out>]): ComposedBlock<In, Out>;
-export declare function composeBlock<In extends Checkpoint<string>, B extends Checkpoint<string>, Out extends Checkpoint<string>>(name: string, steps: readonly [Block<In, B>, Block<B, Out>]): ComposedBlock<In, Out>;
-export declare function composeBlock<In extends Checkpoint<string>, B extends Checkpoint<string>, C extends Checkpoint<string>, Out extends Checkpoint<string>>(name: string, steps: readonly [Block<In, B>, Block<B, C>, Block<C, Out>]): ComposedBlock<In, Out>;
-export declare function composeBlock<In extends Checkpoint<string>, B extends Checkpoint<string>, C extends Checkpoint<string>, D extends Checkpoint<string>, Out extends Checkpoint<string>>(name: string, steps: readonly [Block<In, B>, Block<B, C>, Block<C, D>, Block<D, Out>]): ComposedBlock<In, Out>;
-export declare function composeBlock<In extends Checkpoint<string>, B extends Checkpoint<string>, C extends Checkpoint<string>, D extends Checkpoint<string>, E extends Checkpoint<string>, Out extends Checkpoint<string>>(name: string, steps: readonly [Block<In, B>, Block<B, C>, Block<C, D>, Block<D, E>, Block<E, Out>]): ComposedBlock<In, Out>;
-export declare function composeBlock<In extends Checkpoint<string>, B extends Checkpoint<string>, C extends Checkpoint<string>, D extends Checkpoint<string>, E extends Checkpoint<string>, F extends Checkpoint<string>, Out extends Checkpoint<string>>(name: string, steps: readonly [Block<In, B>, Block<B, C>, Block<C, D>, Block<D, E>, Block<E, F>, Block<F, Out>]): ComposedBlock<In, Out>;
-/**
- * Same shape as {@link composeBlock}, marked {@link FastForwardComposedBlock.fastForward}
- * so demo/run/traverse treat it as **one opaque step** that **blitzes wall-clock**
- * (skip overlay theater + no Playwright slowMo on that step's acts) unless
- * `--ff-expand` / `WAYGRAPH_FF_EXPAND=1`. Inner acts still run for real;
- * failures are prefixed `ff-name > …` so the locus names both the FF unit and
- * the inner step. Prefer this for boring or heavy-check prefixes (auth, seed,
- * dashboard settle) — you may put **several** FF units in one Flow with normal
- * Blocks between them.
- * @example fastForwardComposeBlock("ff-owner-auth", [NavLoginBlock, SubmitLoginForFlow])
- */
-export interface FastForwardComposedBlock<In extends Checkpoint<string>, Out extends Checkpoint<string>> extends ComposedBlock<In, Out> {
-    readonly fastForward: true;
-}
-/** True when `block` came from {@link fastForwardComposeBlock}. */
-export declare function isFastForwardBlock(block: Block<any, any>): block is FastForwardComposedBlock<any, any>;
-export declare function fastForwardComposeBlock<In extends Checkpoint<string>, Out extends Checkpoint<string>>(name: string, steps: readonly [Block<In, Out>]): FastForwardComposedBlock<In, Out>;
-export declare function fastForwardComposeBlock<In extends Checkpoint<string>, B extends Checkpoint<string>, Out extends Checkpoint<string>>(name: string, steps: readonly [Block<In, B>, Block<B, Out>]): FastForwardComposedBlock<In, Out>;
-export declare function fastForwardComposeBlock<In extends Checkpoint<string>, B extends Checkpoint<string>, C extends Checkpoint<string>, Out extends Checkpoint<string>>(name: string, steps: readonly [Block<In, B>, Block<B, C>, Block<C, Out>]): FastForwardComposedBlock<In, Out>;
-export declare function fastForwardComposeBlock<In extends Checkpoint<string>, B extends Checkpoint<string>, C extends Checkpoint<string>, D extends Checkpoint<string>, Out extends Checkpoint<string>>(name: string, steps: readonly [Block<In, B>, Block<B, C>, Block<C, D>, Block<D, Out>]): FastForwardComposedBlock<In, Out>;
-export declare function fastForwardComposeBlock<In extends Checkpoint<string>, B extends Checkpoint<string>, C extends Checkpoint<string>, D extends Checkpoint<string>, E extends Checkpoint<string>, Out extends Checkpoint<string>>(name: string, steps: readonly [Block<In, B>, Block<B, C>, Block<C, D>, Block<D, E>, Block<E, Out>]): FastForwardComposedBlock<In, Out>;
-export declare function fastForwardComposeBlock<In extends Checkpoint<string>, B extends Checkpoint<string>, C extends Checkpoint<string>, D extends Checkpoint<string>, E extends Checkpoint<string>, F extends Checkpoint<string>, Out extends Checkpoint<string>>(name: string, steps: readonly [Block<In, B>, Block<B, C>, Block<C, D>, Block<D, E>, Block<E, F>, Block<F, Out>]): FastForwardComposedBlock<In, Out>;
-/** Configures how an Engine launches its own browser - only used by `Flow.run(mem)` (no context given); ignored by `Flow.run(context, mem)`, since that context is already launched. */
-export interface EngineConfig {
-    /** Default `true`, matching Playwright's own default. */
-    headless?: boolean;
-    /** Default `"chromium"`. */
-    browserName?: "chromium" | "firefox" | "webkit";
-    /** Milliseconds Playwright pauses before each operation - for watching a non-headless run with your own eyes, not for real runs. Default `0`. */
-    slowMo?: number;
-    /**
-     * Overrides which `BrowserType` actually launches, per browser name -
-     * default is the real `@playwright/test` export for whichever one
-     * `browserName` picks. Accepts anything shaped like Playwright's own
-     * `chromium`/`firefox`/`webkit` (same `.launch()` signature) - a
-     * stealth-patched or otherwise customized launcher (e.g. `playwright-extra`
-     * plus a stealth plugin) drops in here unmodified. Puppeteer is a
-     * different `Page`/`BrowserContext` shape entirely and isn't supported by
-     * this seam.
-     * @example new Engine({ browsers: { chromium: stealthChromium } })
-     */
-    browsers?: Partial<Record<"chromium" | "firefox" | "webkit", BrowserType>>;
-    /**
-     * Playwright `recordVideo` - saves a `.webm` when the context closes.
-     * Works headless. Lighter than a full clip-engine pipeline (no overlay/ffmpeg).
-     * @example new Engine({ recordVideo: { dir: "./videos" } })
-     */
-    recordVideo?: {
-        dir: string;
-        size?: {
-            width: number;
-            height: number;
-        };
-    };
-    /**
-     * Cross-cutting, automatically-enforced verify (see {@link defineLayout})
-     * - applies to every Flow this Engine defines. Works the same regardless
-     * of folder convention (Waygraph Map or freeform "manual mode") since
-     * matching is by Checkpoint tag, never by file path.
-     * @example new Engine({ layouts: [AppShellLayout] })
-     */
-    layouts?: readonly Layout[];
-}
-type S = Checkpoint<"__start__">;
-/**
- * Holds engine-level configuration shared across every flow defined from it -
- * for now, just how to launch a browser when a Flow owns its own
- * (`headless`/`browserName`/`slowMo`); traits/interstitials/watchers land here
- * in a later change.
- * @example const engine = new Engine({ headless: false, slowMo: 250 });
- */
-export declare class Engine {
-    private readonly config;
-    constructor(config?: EngineConfig);
-    /**
-     * Builds a runnable {@link Flow} from `[start, ...Blocks, end]`, typechecked
-     * so each Block's `In` must match the previous Block's `Out` - the same
-     * check `connect()` does, just declared as a flat array instead of hand-nested
-     * calls. Overloaded for 2-9 array slots (1-8 real Blocks between `start`/`end`)
-     * rather than one fully-generic recursive tuple type, so each arity is as
-     * reliably checked as `connect<A,B,C>` itself.
-     * @example engine.defineFlow([start, LoginBlock, AddToCartBlock, end])
-     */
-    defineFlow<B extends Checkpoint<string>>(blocks: readonly [StartMarker, Block<S, B>, EndMarker]): Flow<B>;
-    defineFlow<B extends Checkpoint<string>, C extends Checkpoint<string>>(blocks: readonly [StartMarker, Block<S, B>, Block<B, C>, EndMarker]): Flow<C>;
-    defineFlow<B extends Checkpoint<string>, C extends Checkpoint<string>, D extends Checkpoint<string>>(blocks: readonly [StartMarker, Block<S, B>, Block<B, C>, Block<C, D>, EndMarker]): Flow<D>;
-    defineFlow<B extends Checkpoint<string>, C extends Checkpoint<string>, D extends Checkpoint<string>, E extends Checkpoint<string>>(blocks: readonly [StartMarker, Block<S, B>, Block<B, C>, Block<C, D>, Block<D, E>, EndMarker]): Flow<E>;
-    defineFlow<B extends Checkpoint<string>, C extends Checkpoint<string>, D extends Checkpoint<string>, E extends Checkpoint<string>, F extends Checkpoint<string>>(blocks: readonly [
-        StartMarker,
-        Block<S, B>,
-        Block<B, C>,
-        Block<C, D>,
-        Block<D, E>,
-        Block<E, F>,
-        EndMarker
-    ]): Flow<F>;
-    defineFlow<B extends Checkpoint<string>, C extends Checkpoint<string>, D extends Checkpoint<string>, E extends Checkpoint<string>, F extends Checkpoint<string>, G extends Checkpoint<string>>(blocks: readonly [
-        StartMarker,
-        Block<S, B>,
-        Block<B, C>,
-        Block<C, D>,
-        Block<D, E>,
-        Block<E, F>,
-        Block<F, G>,
-        EndMarker
-    ]): Flow<G>;
-    defineFlow<B extends Checkpoint<string>, C extends Checkpoint<string>, D extends Checkpoint<string>, E extends Checkpoint<string>, F extends Checkpoint<string>, G extends Checkpoint<string>, H extends Checkpoint<string>>(blocks: readonly [
-        StartMarker,
-        Block<S, B>,
-        Block<B, C>,
-        Block<C, D>,
-        Block<D, E>,
-        Block<E, F>,
-        Block<F, G>,
-        Block<G, H>,
-        EndMarker
-    ]): Flow<H>;
-    defineFlow<B extends Checkpoint<string>, C extends Checkpoint<string>, D extends Checkpoint<string>, E extends Checkpoint<string>, F extends Checkpoint<string>, G extends Checkpoint<string>, H extends Checkpoint<string>, I extends Checkpoint<string>>(blocks: readonly [
-        StartMarker,
-        Block<S, B>,
-        Block<B, C>,
-        Block<C, D>,
-        Block<D, E>,
-        Block<E, F>,
-        Block<F, G>,
-        Block<G, H>,
-        Block<H, I>,
-        EndMarker
-    ]): Flow<I>;
-    defineFlow<B extends Checkpoint<string>, C extends Checkpoint<string>, D extends Checkpoint<string>, E extends Checkpoint<string>, F extends Checkpoint<string>, G extends Checkpoint<string>, H extends Checkpoint<string>, I extends Checkpoint<string>, J extends Checkpoint<string>>(blocks: readonly [
-        StartMarker,
-        Block<S, B>,
-        Block<B, C>,
-        Block<C, D>,
-        Block<D, E>,
-        Block<E, F>,
-        Block<F, G>,
-        Block<G, H>,
-        Block<H, I>,
-        Block<I, J>,
-        EndMarker
-    ]): Flow<J>;
-    defineFlow<B extends Checkpoint<string>, C extends Checkpoint<string>, D extends Checkpoint<string>, E extends Checkpoint<string>, F extends Checkpoint<string>, G extends Checkpoint<string>, H extends Checkpoint<string>, I extends Checkpoint<string>, J extends Checkpoint<string>, K extends Checkpoint<string>>(blocks: readonly [
-        StartMarker,
-        Block<S, B>,
-        Block<B, C>,
-        Block<C, D>,
-        Block<D, E>,
-        Block<E, F>,
-        Block<F, G>,
-        Block<G, H>,
-        Block<H, I>,
-        Block<I, J>,
-        Block<J, K>,
-        EndMarker
-    ]): Flow<K>;
-    defineFlow<B extends Checkpoint<string>, C extends Checkpoint<string>, D extends Checkpoint<string>, E extends Checkpoint<string>, F extends Checkpoint<string>, G extends Checkpoint<string>, H extends Checkpoint<string>, I extends Checkpoint<string>, J extends Checkpoint<string>, K extends Checkpoint<string>, L extends Checkpoint<string>>(blocks: readonly [
-        StartMarker,
-        Block<S, B>,
-        Block<B, C>,
-        Block<C, D>,
-        Block<D, E>,
-        Block<E, F>,
-        Block<F, G>,
-        Block<G, H>,
-        Block<H, I>,
-        Block<I, J>,
-        Block<J, K>,
-        Block<K, L>,
-        EndMarker
-    ]): Flow<L>;
-    defineFlow<B extends Checkpoint<string>, C extends Checkpoint<string>, D extends Checkpoint<string>, E extends Checkpoint<string>, F extends Checkpoint<string>, G extends Checkpoint<string>, H extends Checkpoint<string>, I extends Checkpoint<string>, J extends Checkpoint<string>, K extends Checkpoint<string>, L extends Checkpoint<string>, M extends Checkpoint<string>>(blocks: readonly [
-        StartMarker,
-        Block<S, B>,
-        Block<B, C>,
-        Block<C, D>,
-        Block<D, E>,
-        Block<E, F>,
-        Block<F, G>,
-        Block<G, H>,
-        Block<H, I>,
-        Block<I, J>,
-        Block<J, K>,
-        Block<K, L>,
-        Block<L, M>,
-        EndMarker
-    ]): Flow<M>;
-    defineFlow<B extends Checkpoint<string>, C extends Checkpoint<string>, D extends Checkpoint<string>, E extends Checkpoint<string>, F extends Checkpoint<string>, G extends Checkpoint<string>, H extends Checkpoint<string>, I extends Checkpoint<string>, J extends Checkpoint<string>, K extends Checkpoint<string>, L extends Checkpoint<string>, M extends Checkpoint<string>, N extends Checkpoint<string>>(blocks: readonly [
-        StartMarker,
-        Block<S, B>,
-        Block<B, C>,
-        Block<C, D>,
-        Block<D, E>,
-        Block<E, F>,
-        Block<F, G>,
-        Block<G, H>,
-        Block<H, I>,
-        Block<I, J>,
-        Block<J, K>,
-        Block<K, L>,
-        Block<L, M>,
-        Block<M, N>,
-        EndMarker
-    ]): Flow<N>;
-    defineFlow<B extends Checkpoint<string>, C extends Checkpoint<string>, D extends Checkpoint<string>, E extends Checkpoint<string>, F extends Checkpoint<string>, G extends Checkpoint<string>, H extends Checkpoint<string>, I extends Checkpoint<string>, J extends Checkpoint<string>, K extends Checkpoint<string>, L extends Checkpoint<string>, M extends Checkpoint<string>, N extends Checkpoint<string>, O extends Checkpoint<string>>(blocks: readonly [
-        StartMarker,
-        Block<S, B>,
-        Block<B, C>,
-        Block<C, D>,
-        Block<D, E>,
-        Block<E, F>,
-        Block<F, G>,
-        Block<G, H>,
-        Block<H, I>,
-        Block<I, J>,
-        Block<J, K>,
-        Block<K, L>,
-        Block<L, M>,
-        Block<M, N>,
-        Block<N, O>,
-        EndMarker
-    ]): Flow<O>;
-    /**
-     * Fluent, kind-checked alternative to `defineFlow([start, ...blocks, end])` -
-     * see {@link MapBuilder}. Real, direct request this responds to: pia/zsign's
-     * own agents kept hand-editing/hand-composing Blocks into ad hoc shapes
-     * ("locks" convention tried, still got broken) - `map()` forces every step
-     * through this Engine's own `define*Block` factories (checked by the same
-     * `__waygraphKind`/`__waygraphSalt` runtime markers `graph.ts`/`map-check.ts`
-     * already trust), so a hand-rolled plain-object Block can never silently
-     * pass as a real navigation/assertion/method step. `homeOrigin`, if given,
-     * also gates `.gotoPage()`/`.gotoExternal()` against each Nav/Page Block's
-     * own static `url` (skipped, honestly, for click-based/dynamic nav - not
-     * statically checkable, same limitation `map-check.ts` already documents).
-     * @example
-     * const flow = engine.map({ homeOrigin: "https://app.example.com" })
-     *   .start()
-     *   .gotoPage(NavHomeBlock)
-     *   .assert(AssertHelloBlock)
-     *   .gotoExternal(NavMailpitBlock)
-     *   .end();
-     */
-    map(options?: MapBuilderOptions): MapBuilder<S>;
-}
-export interface MapBuilderOptions {
-    /**
-     * This project's own origin (e.g. `"https://app.example.com"`) - enables
-     * `.gotoPage()`/`.gotoExternal()`'s origin check against a Block's static
-     * `url`. Omit to skip that check entirely (still fully kind-checked either
-     * way; only the internal/external origin distinction is opt-in).
-     */
-    homeOrigin?: string;
-}
-/**
- * Fluent builder over {@link Engine.defineFlow} - see `map()`'s own doc
- * comment for why this exists. Each step method is scoped to exactly the
- * Block kind its name promises, checked at RUNTIME against the
- * `__waygraphKind`/`__waygraphSalt` markers `defineNavBlock`/`definePageBlock`/
- * `defineAssertBlock`/`defineMethodBlock`/`defineEffectBlock` already set
- * (the same markers `graph.ts` and `map-check.ts` trust) - not just a type
- * hint, since a hand-rolled object can satisfy the TypeScript `Block<In,Out>`
- * shape without ever going through a real factory. Each call also
- * typechecks the accumulated Checkpoint chain exactly like `defineFlow`'s
- * own tuple overloads do (a step's `In` must equal the previous step's
- * `Out`) - this is what "no teleporting" means: there is no method on this
- * builder that can skip from one Checkpoint to an unrelated one without a
- * real, kind-correct Block in between.
- */
-export declare class MapBuilder<Out extends Checkpoint<string>> {
-    private readonly engine;
-    private readonly steps;
-    private readonly homeOrigin;
-    private readonly ff;
-    private constructor();
-    /** @internal - use `engine.map()` or the standalone `map()` export. */
-    static begin(engine: Engine, homeOrigin: string | undefined): MapBuilder<S>;
-    /** Readable chain-opener - mirrors `defineFlow`'s leading `start` sentinel. Returns `this` unchanged; entirely optional. */
-    start(): MapBuilder<Out>;
-    /**
-     * Open a fast-forward window - steps until {@link ffEnd} collapse into one
-     * opaque `fastForwardComposeBlock` (blitz theater). Kind/salt checks still
-     * run on each inner step as it is added.
-     */
-    ffStart(name?: string): MapBuilder<Out>;
-    /**
-     * Close the current fast-forward window and append one FFCompose step.
-     * Throws if empty or if {@link ffStart} was never opened.
-     */
-    ffEnd(): MapBuilder<Out>;
-    private appendStep;
-    /**
-     * Appends an internal navigation/page-arrival step - requires a Block from
-     * `defineNavBlock`/`defineMemNavBlock`/`definePageBlock`. Throws if given
-     * anything else, including a `homeOrigin`-mismatched static `url`.
-     * Compile-time: {@link NavBlock} or {@link PageBlock} only (not Assert/Method).
-     */
-    gotoPage<NextOut extends Checkpoint<string>>(block: (NavBlock<NextOut> | PageBlock<NextOut>) & {
-        name: string;
-    }): MapBuilder<NextOut>;
-    /**
-     * Appends a genuinely cross-origin navigation step (e.g. `(external)/`
-     * Blocks in the Waygraph Map convention: mailpit, maildrop.cc) - same
-     * kind requirement as {@link gotoPage}, plus the inverse `homeOrigin` check.
-     * Compile-time: {@link NavBlock} or {@link PageBlock} only.
-     */
-    gotoExternal<NextOut extends Checkpoint<string>>(block: (NavBlock<NextOut> | PageBlock<NextOut>) & {
-        name: string;
-    }): MapBuilder<NextOut>;
-    /**
-     * Appends a self-loop verification step - requires a Block from
-     * `defineAssertBlock`. Compile-time: {@link AssertBlock} only (not `.method()`).
-     */
-    assert(block: AssertBlock<Out> & {
-        name: string;
-    }): MapBuilder<Out>;
-    /**
-     * Appends a non-navigating page action (submit, upload, add/remove an
-     * instance) - requires a Block from `defineMethodBlock`/`defineActionBlock`/
-     * `defineEffectBlock`/`defineMemEffectBlock`.
-     * Compile-time: {@link MethodBlock} or {@link EffectBlock} only - Assert
-     * Blocks must use `.assert()`. Runtime also rejects `__waygraphKind =
-     * "assert"` (those still carry method salt from the factory internals).
-     */
-    method<NextOut extends Checkpoint<string>>(block: (MethodBlock<Out, NextOut> | EffectBlock<Out, NextOut>) & {
-        name: string;
-    }): MapBuilder<NextOut>;
-    /**
-     * Finalizes this chain into a real, runnable {@link Flow} - same object
-     * `defineFlow` returns, so `withBlockVerify`/`modBlockVerify` and every
-     * `withTitle`/`withHighlightFixtures`/etc. decorator still apply exactly
-     * as they do today; this builder only changes how the chain is assembled,
-     * never what it produces. Throws if no step was ever added - an empty map
-     * isn't a flow.
-     */
-    end(): Flow<Out>;
-}
-/**
- * Standalone convenience for `new Engine(config).map(options)` - use this
- * when a call site doesn't otherwise need its own `Engine` instance (no
- * shared `headless`/`slowMo`/`layouts` across several flows).
- * @example const flow = map({ homeOrigin: "https://app.example.com" }).gotoPage(NavHomeBlock).end();
- */
-export declare function map(options?: MapBuilderOptions & EngineConfig): MapBuilder<S>;
-/**
- * Attaches routing to `block` without touching its act/observe/resolve/verify -
- * `routes` must cover every tag of `block`'s output (a missing route is a compile
- * error), and the returned Block runs exactly as `block` always did, just followed
- * by whichever next Block the resolved tag routes to. `null` for a tag means that
- * tag is terminal - the run stops there, same as a Block with no routing at all.
- * A route pointing back at `block` itself is a self-loop; see `runGraph`'s
- * `maxSteps` for its safety net. The return type is deliberately `Block<In, any>` -
- * a route can lead anywhere, including back through itself, so there is no fixed
- * Out type to express; state the expected outcomes to `runGraph` via `terminals`
- * instead.
- */
-export declare function branch<In extends Checkpoint<string>, Out extends Checkpoint<string>>(block: Block<In, Out>, routes: {
-    [K in Out["__state"]]: Block<Extract<Out, Checkpoint<K>>, any> | null;
-}): DefinedBlock<In, any>;
-/**
- * Builds a Block with `withVerify`/`modVerify`/`modVerifyAll` attached as
- * methods - `LoginBlock.withVerify([...])`, discoverable by typing
- * `LoginBlock.` in an editor, not just callable as `withVerify(LoginBlock, ...)`
- * if you already know it exists. A raw object literal is still a perfectly
- * valid Block (every test fixture in this codebase is one) - it just won't have
- * these attached. The methods are thin: they delegate to the identically-named
- * free functions, which remain the one place this logic actually lives.
- */
-export declare function defineBlock<In extends Checkpoint<string>, Out extends Checkpoint<string>>(base: {
-    name: string;
-    description?: Block<In, Out>["description"];
-    instruction: Omit<Instruction<In, Out, any>, "act"> & {
-        act(page: ActionPage, input: In, mem: MemPage): Promise<void>;
-    };
-    next?: Block<In, Out>["next"];
-    requires?: Block<In, Out>["requires"];
-    routes?: Block<In, Out>["routes"];
-    instanceOptions?: Block<In, Out>["instanceOptions"];
-}): DefinedBlock<In, Out>;
-/**
- * A Block whose only possible action is navigating to a URL - built via
- * {@link defineNavBlock}, never with a hand-authored `act()`. Extends `Block`
- * (same shape `DefinedBlock`/`ComposedBlock` already use), so it drops into
- * `defineFlow([...])`, `connect()`, `composeBlock()` exactly like any other
- * Block - no special-casing needed anywhere that only expects a `Block`.
- * See `openspec/specs/nav-block-and-check/spec.md` for why this exists.
- *
- * `__wgFactory` is a TypeScript-only brand so {@link MapBuilder.gotoPage} /
- * {@link MapBuilder.gotoExternal} can reject Assert/Method Blocks at compile
- * time (runtime still checks `__waygraphKind`). Decorate methods are re-stated
- * (via Omit) so `.stubBefore()` / `.withVerify()` keep the brand.
- */
-export type NavBlock<Out extends Checkpoint<string>> = Omit<DefinedBlock<Checkpoint<string>, Out>, "withVerify" | "modVerify" | "modVerifyAll" | "stubBefore" | "stubAfter" | "stubOnError"> & {
-    readonly __wgFactory?: "nav";
-    withVerify(verify: Trait[] | ((out: Out) => Trait[])): NavBlock<Out>;
-    modVerify(nameOrIndex: string | number, newCheck: Trait["check"] | Trait): NavBlock<Out>;
-    modVerifyAll(patches: Record<string, Trait["check"] | Trait>): NavBlock<Out>;
-    stubBefore(stub: import("./highlights.js").HighlightStubPhase): NavBlock<Out>;
-    stubBefore(stub: import("./highlights.js").StubLifecycleFn<Out>): NavBlock<Out>;
-    stubBefore(stub: (out: Out) => import("./highlights.js").HighlightStubPhase): NavBlock<Out>;
-    stubAfter(stub: import("./highlights.js").HighlightStubPhase): NavBlock<Out>;
-    stubAfter(stub: import("./highlights.js").StubLifecycleFn<Out>): NavBlock<Out>;
-    stubAfter(stub: (out: Out) => import("./highlights.js").HighlightStubPhase): NavBlock<Out>;
-    stubOnError(stub: import("./highlights.js").HighlightStubPhase): NavBlock<Out>;
-    stubOnError(stub: import("./highlights.js").StubLifecycleFn<Out>): NavBlock<Out>;
-    stubOnError(stub: (out: Out) => import("./highlights.js").HighlightStubPhase): NavBlock<Out>;
-};
-/**
- * `defineNavBlock`'s own options - exactly one of `url`/`click` required,
- * enforced at compile time (giving both, or neither, is a type error - see
- * `typecheck/nav-block.types.ts`). `checkpoint` is the tag this NavBlock
- * resolves to once navigation completes - a NavBlock never branches on
- * observed evidence the way a regular Block can, so there's no `resolve`
- * logic to author; it always just declares "arrived."
- */
-export type NavBlockOptions<Out extends Checkpoint<string>> = {
-    name: string;
-    description?: string;
-    checkpoint: Out["__state"];
-    requires?: readonly MemKey<any>[];
-    verify?: Trait[] | ((out: Out) => Trait[]);
-    stubBefore?: import("./highlights.js").HighlightStubPhaseOrFn<Out>;
-    stubAfter?: import("./highlights.js").HighlightStubPhaseOrFn<Out>;
-    stubOnError?: import("./highlights.js").HighlightStubPhaseOrFn<Out>;
-    /** @deprecated Prefer stubAfter. */
-    highlights?: readonly WaygraphHighlight[] | ((out: Out) => readonly WaygraphHighlight[]);
-    /**
-     * Live per-instance menu rows for `waygraph auto` (see {@link Block.instanceOptions}).
-     * When set, the explore menu lists one row per option instead of a single
-     * generic nav edge - used by {@link defineMemNavBlock}.
-     */
-    instanceOptions?: Block<Checkpoint<string>, Out>["instanceOptions"];
-} & ({
-    /**
-     * Direct URL navigation. Accepts a plain string or a function
-     * `(mem) => string` for parameterized routes (e.g.
-     * `/dashboard/requests/:id` with a real id read from mem). The
-     * escape hatch for the few real cases with no click path to get
-     * there (a deep link from an email, a public share link) - not for
-     * skipping past navigation an agent didn't feel like finding. Prefer
-     * `click` whenever the target app actually has one.
-     */
-    url: string | ((mem: MemPage) => string);
-    click?: never;
-} | {
-    /**
-     * Navigates by clicking a real element already on the page (a nav
-     * link, a sidebar item) instead of teleporting straight to a URL -
-     * the opinionated default. Accepts a Playwright selector string, or
-     * a function `(mem) => selector` for a target that depends on mem
-     * (e.g. clicking the row for a specific id). Verifying arrival is
-     * `verify`'s job (typically `Trait.url(...)`), same as a `url`-based
-     * NavBlock - the click itself is only ever awaited for its own
-     * completion, not for whatever navigation it triggers.
-     */
-    click: string | ((mem: MemPage) => string);
-    url?: never;
-});
-/**
- * Builds a {@link NavBlock}. The generated `act()` is always exactly
- * `page.goto(url)` or `page.locator(click).click()` - never anything else,
- * never author-supplied. Callers get a real `Page` here internally (the one
- * legitimate place navigation belongs); `defineBlock`'s own `ActionPage`
- * narrowing is what discourages navigation everywhere else, and never
- * applies to this generated function since no author ever writes it by
- * hand.
- * @example defineNavBlock({ name: "nav-web-login", checkpoint: "LoginForm", url: "/login" })
- * @example defineNavBlock({ name: "nav-web-request-detail", checkpoint: "RequestDetail", url: (mem) => `/dashboard/requests/${mem.get(RequestId.key)}` })
- * @example defineNavClickBlock({ name: "nav-web-documents", checkpoint: "DocumentsList", click: "nav >> text=Documents" })
- * For click-nav in app code prefer {@link defineNavClickBlock} (url stays here).
- */
-export declare function defineNavBlock<Out extends Checkpoint<string>>(options: NavBlockOptions<Out>): NavBlock<Out>;
-/**
- * Click-only {@link NavBlock}. Same runtime as {@link defineNavBlock} with
- * `click` - use this in app code so you never wonder whether a Nav is url or
- * click (no `__waygraphNavClick` sniffing at author time). Prefer
- * {@link defineNavBlock} only for `url` / `goto` deep links.
- */
-export type NavClickBlockOptions<Out extends Checkpoint<string>> = {
-    name: string;
-    description?: string;
-    checkpoint: Out["__state"];
-    click: string | ((mem: MemPage) => string);
-    requires?: readonly MemKey<any>[];
-    verify?: Trait[] | ((out: Out) => Trait[]);
-    stubBefore?: import("./highlights.js").HighlightStubPhaseOrFn<Out>;
-    stubAfter?: import("./highlights.js").HighlightStubPhaseOrFn<Out>;
-    stubOnError?: import("./highlights.js").HighlightStubPhaseOrFn<Out>;
-    /** @deprecated Prefer stubAfter. */
-    highlights?: readonly WaygraphHighlight[] | ((out: Out) => readonly WaygraphHighlight[]);
-    instanceOptions?: Block<Checkpoint<string>, Out>["instanceOptions"];
-};
-export type NavClickBlock<Out extends Checkpoint<string>> = NavBlock<Out>;
-/** @see {@link NavClickBlockOptions} */
-export declare function defineNavClickBlock<Out extends Checkpoint<string>>(options: NavClickBlockOptions<Out>): NavClickBlock<Out>;
-/**
- * TypeScript salt over {@link defineBlock} for one-shot non-nav app steps
- * (submit, upload, finish, logout) - **methods** on a page. Same runtime Block;
- * marks `__waygraphSalt = "method"` so auto/docs can tell Method from bare
- * {@link defineBlock}. Does not force `instanceOptions` - use
- * {@link defineEffectBlock} when the auto menu should spawn one row per live
- * DOM instance. Prefer hanging methods off a {@link definePageBlock} hub.
- */
-export type MethodBlock<In extends Checkpoint<string>, Out extends Checkpoint<string>> = Omit<DefinedBlock<In, Out>, "withVerify" | "modVerify" | "modVerifyAll" | "stubBefore" | "stubAfter" | "stubOnError"> & {
-    readonly __wgFactory?: "method";
-    withVerify(verify: Trait[] | ((out: Out) => Trait[])): MethodBlock<In, Out>;
-    modVerify(nameOrIndex: string | number, newCheck: Trait["check"] | Trait): MethodBlock<In, Out>;
-    modVerifyAll(patches: Record<string, Trait["check"] | Trait>): MethodBlock<In, Out>;
-    stubBefore(stub: import("./highlights.js").HighlightStubPhase): MethodBlock<In, Out>;
-    stubBefore(stub: import("./highlights.js").StubLifecycleFn<Out>): MethodBlock<In, Out>;
-    stubBefore(stub: (out: Out) => import("./highlights.js").HighlightStubPhase): MethodBlock<In, Out>;
-    stubAfter(stub: import("./highlights.js").HighlightStubPhase): MethodBlock<In, Out>;
-    stubAfter(stub: import("./highlights.js").StubLifecycleFn<Out>): MethodBlock<In, Out>;
-    stubAfter(stub: (out: Out) => import("./highlights.js").HighlightStubPhase): MethodBlock<In, Out>;
-    stubOnError(stub: import("./highlights.js").HighlightStubPhase): MethodBlock<In, Out>;
-    stubOnError(stub: import("./highlights.js").StubLifecycleFn<Out>): MethodBlock<In, Out>;
-    stubOnError(stub: (out: Out) => import("./highlights.js").HighlightStubPhase): MethodBlock<In, Out>;
-};
-/** @deprecated Prefer {@link MethodBlock} - same type; Action was the 0.7 name. */
-export type ActionBlock<In extends Checkpoint<string>, Out extends Checkpoint<string>> = MethodBlock<In, Out>;
-export declare function defineMethodBlock<In extends Checkpoint<string>, Out extends Checkpoint<string>>(base: Parameters<typeof defineBlock<In, Out>>[0]): MethodBlock<In, Out>;
-/** @deprecated Prefer {@link defineMethodBlock} - identical helper (0.7 name). */
-export declare const defineActionBlock: typeof defineMethodBlock;
-export interface AssertBlockOptions<Out extends Checkpoint<string> = Checkpoint<string>> {
-    name: string;
-    description?: string;
-    /** Self-loop target - the Checkpoint this assertion runs on and returns to. */
-    checkpoint: Out["__state"];
-    /**
-     * Shorthand for the wait-then-assert shape found repeatedly in hand-written
-     * assertion Blocks: waits for a heading with this accessible name before
-     * `verify` runs. Omit for a pure "assert whatever is already on the page"
-     * check with no wait. Not a general `act()` override - a Block that needs
-     * more than this stays a plain `defineMethodBlock`.
-     */
-    waitForHeading?: string;
-    verify: Trait[] | ((out: Out) => Trait[]);
-    /** Mem keys this assertion's `verify` reads (e.g. a mem-aware Trait) - checked by preflight before the flow runs. */
-    requires?: readonly MemKey<any>[];
-    stubBefore?: import("./highlights.js").HighlightStubPhaseOrFn<Out>;
-    stubAfter?: import("./highlights.js").HighlightStubPhaseOrFn<Out>;
-    stubOnError?: import("./highlights.js").HighlightStubPhaseOrFn<Out>;
-    /** Multi-step yap slides (demo only) - same field `Instruction.slides` exposes elsewhere. */
-    slides?: import("./highlights.js").WaygraphSlidesOrFn<Out>;
-}
-/**
- * Sugar for a self-loop-only "pure assertion" Block: no hand-written
- * `act`/`resolve`, just a name, a `checkpoint` tag, and a `verify` array.
- * `resolve` is generated from the one `checkpoint` field given, closing the
- * copy/rename footgun where a hand-restated checkpoint string can silently
- * drift wrong across a copy/pasted file. Mirrors `definePageBlock`'s own
- * construction pattern (flat options in, `defineBlock` built internally).
- * See openspec/changes/waygraph-agent-skill-hardening/spec.md.
- * @example
- * defineAssertBlock({
- *   name: "assert-raw-materials-table",
- *   checkpoint: "RawMaterials",
- *   waitForHeading: "Raw Materials & Lead Times",
- *   verify: [Trait.visible(RawMaterialsSel.reorderBadge)],
- * });
- */
-export declare function defineAssertBlock<Out extends Checkpoint<string> = Checkpoint<string>>(options: AssertBlockOptions<Out>): AssertBlock<Out>;
-/**
- * Self-loop verify Block from {@link defineAssertBlock}. Branded for
- * {@link MapBuilder.assert} (not accepted by `.method()`).
- */
-export type AssertBlock<Out extends Checkpoint<string>> = Omit<DefinedBlock<Out, Out>, "withVerify" | "modVerify" | "modVerifyAll" | "stubBefore" | "stubAfter" | "stubOnError"> & {
-    readonly __wgFactory?: "assert";
-    withVerify(verify: Trait[] | ((out: Out) => Trait[])): AssertBlock<Out>;
-    modVerify(nameOrIndex: string | number, newCheck: Trait["check"] | Trait): AssertBlock<Out>;
-    modVerifyAll(patches: Record<string, Trait["check"] | Trait>): AssertBlock<Out>;
-    stubBefore(stub: import("./highlights.js").HighlightStubPhase): AssertBlock<Out>;
-    stubBefore(stub: import("./highlights.js").StubLifecycleFn<Out>): AssertBlock<Out>;
-    stubBefore(stub: (out: Out) => import("./highlights.js").HighlightStubPhase): AssertBlock<Out>;
-    stubAfter(stub: import("./highlights.js").HighlightStubPhase): AssertBlock<Out>;
-    stubAfter(stub: import("./highlights.js").StubLifecycleFn<Out>): AssertBlock<Out>;
-    stubAfter(stub: (out: Out) => import("./highlights.js").HighlightStubPhase): AssertBlock<Out>;
-    stubOnError(stub: import("./highlights.js").HighlightStubPhase): AssertBlock<Out>;
-    stubOnError(stub: import("./highlights.js").StubLifecycleFn<Out>): AssertBlock<Out>;
-    stubOnError(stub: (out: Out) => import("./highlights.js").HighlightStubPhase): AssertBlock<Out>;
-};
-/** One Block (or lazy factory) registered on a {@link PageBlock}. */
-export type PageMethodEntry = DefinedBlock<any, any> | (() => DefinedBlock<any, any>);
-export type PageBlockOptions<Out extends Checkpoint<string>> = {
-    name: string;
-    description?: string;
-    /** Checkpoint tag for this screen (hub). */
-    checkpoint: Out["__state"];
-    verify?: Trait[] | ((out: Out) => Trait[]);
-    stubBefore?: import("./highlights.js").HighlightStubPhaseOrFn<Out>;
-    stubAfter?: import("./highlights.js").HighlightStubPhaseOrFn<Out>;
-    stubOnError?: import("./highlights.js").HighlightStubPhaseOrFn<Out>;
-    /** @deprecated Prefer stubAfter. */
-    highlights?: readonly WaygraphHighlight[] | ((out: Out) => readonly WaygraphHighlight[]);
-    requires?: readonly MemKey<any>[];
-    /**
-     * Methods available on this page. Array, or a record of Blocks / `() => Block`
-     * factories (lazy so the page object can colocate method definitions).
-     */
-    methods?: readonly PageMethodEntry[] | Record<string, PageMethodEntry>;
-    /**
-     * Optional deep-link onto this page (`goto`). XOR with `click`. Omit when the
-     * hub is arrival-only (previous Block already resolved here).
-     */
-    url?: string | ((mem: MemPage) => string);
-    /** Optional click-nav onto this page. XOR with `url`. */
-    click?: string | ((mem: MemPage) => string);
-    instanceOptions?: Block<Checkpoint<string>, Out>["instanceOptions"];
-};
-/**
- * Page hub Block: one Checkpoint = this screen; methods hang off the hub for
- * readability / auto grouping. Runtime is still a Block (`__waygraphKind = "page"`).
- * `act` is goto/click when `url`/`click` is set, otherwise a no-op (already here).
- * Child methods stay ordinary Blocks for graph edges - the page only registers them.
- * Branded `__wgFactory: "page"` (not `"nav"`) - both are accepted by
- * {@link MapBuilder.gotoPage} / {@link MapBuilder.gotoExternal}.
- */
-export type PageBlock<Out extends Checkpoint<string>> = Omit<DefinedBlock<Checkpoint<string>, Out>, "withVerify" | "modVerify" | "modVerifyAll" | "stubBefore" | "stubAfter" | "stubOnError"> & {
-    readonly __wgFactory?: "page";
-    /** Resolved method Blocks registered at define time. */
-    readonly methods: readonly DefinedBlock<any, any>[];
-    withVerify(verify: Trait[] | ((out: Out) => Trait[])): PageBlock<Out>;
-    modVerify(nameOrIndex: string | number, newCheck: Trait["check"] | Trait): PageBlock<Out>;
-    modVerifyAll(patches: Record<string, Trait["check"] | Trait>): PageBlock<Out>;
-    stubBefore(stub: import("./highlights.js").HighlightStubPhase): PageBlock<Out>;
-    stubBefore(stub: import("./highlights.js").StubLifecycleFn<Out>): PageBlock<Out>;
-    stubBefore(stub: (out: Out) => import("./highlights.js").HighlightStubPhase): PageBlock<Out>;
-    stubAfter(stub: import("./highlights.js").HighlightStubPhase): PageBlock<Out>;
-    stubAfter(stub: import("./highlights.js").StubLifecycleFn<Out>): PageBlock<Out>;
-    stubAfter(stub: (out: Out) => import("./highlights.js").HighlightStubPhase): PageBlock<Out>;
-    stubOnError(stub: import("./highlights.js").HighlightStubPhase): PageBlock<Out>;
-    stubOnError(stub: import("./highlights.js").StubLifecycleFn<Out>): PageBlock<Out>;
-    stubOnError(stub: (out: Out) => import("./highlights.js").HighlightStubPhase): PageBlock<Out>;
-};
-/** @see {@link PageBlockOptions} */
-export declare function definePageBlock<Out extends Checkpoint<string>>(options: PageBlockOptions<Out>): PageBlock<Out>;
-/**
- * TypeScript salt over {@link defineBlock}: same runtime Block, but the type
- * forces `requires` + `instanceOptions` so `waygraph auto` can list one menu
- * row per live instance (add/remove/toggle). Not a separate engine concept -
- * everything is still a Block.
- */
-export type EffectBlock<In extends Checkpoint<string>, Out extends Checkpoint<string>> = Omit<DefinedBlock<In, Out>, "withVerify" | "modVerify" | "modVerifyAll" | "stubBefore" | "stubAfter" | "stubOnError"> & {
-    readonly __wgFactory?: "effect";
-    requires: readonly MemKey<any>[];
-    instanceOptions: NonNullable<Block<In, Out>["instanceOptions"]>;
-    withVerify(verify: Trait[] | ((out: Out) => Trait[])): EffectBlock<In, Out>;
-    modVerify(nameOrIndex: string | number, newCheck: Trait["check"] | Trait): EffectBlock<In, Out>;
-    modVerifyAll(patches: Record<string, Trait["check"] | Trait>): EffectBlock<In, Out>;
-    stubBefore(stub: import("./highlights.js").HighlightStubPhase): EffectBlock<In, Out>;
-    stubBefore(stub: import("./highlights.js").StubLifecycleFn<Out>): EffectBlock<In, Out>;
-    stubBefore(stub: (out: Out) => import("./highlights.js").HighlightStubPhase): EffectBlock<In, Out>;
-    stubAfter(stub: import("./highlights.js").HighlightStubPhase): EffectBlock<In, Out>;
-    stubAfter(stub: import("./highlights.js").StubLifecycleFn<Out>): EffectBlock<In, Out>;
-    stubAfter(stub: (out: Out) => import("./highlights.js").HighlightStubPhase): EffectBlock<In, Out>;
-    stubOnError(stub: import("./highlights.js").HighlightStubPhase): EffectBlock<In, Out>;
-    stubOnError(stub: import("./highlights.js").StubLifecycleFn<Out>): EffectBlock<In, Out>;
-    stubOnError(stub: (out: Out) => import("./highlights.js").HighlightStubPhase): EffectBlock<In, Out>;
-};
-/** @deprecated Prefer {@link EffectBlock} - same type; Mem* was an early name. */
-export type MemEffectBlock<In extends Checkpoint<string>, Out extends Checkpoint<string>> = EffectBlock<In, Out>;
-/**
- * TypeScript salt over {@link defineNavBlock}: mem-picked destination
- * (which product row / which request id). Still a NavBlock / Block at runtime.
- */
-export type MemNavBlock<Out extends Checkpoint<string>> = NavBlock<Out> & {
-    requires: readonly MemKey<any>[];
-    instanceOptions: NonNullable<Block<Checkpoint<string>, Out>["instanceOptions"]>;
-};
-/**
- * {@link defineBlock} constrained for effect-style instance menus: `requires` +
- * `instanceOptions` are mandatory. Prefer this when the Block adds / removes /
- * toggles a live instance rather than navigating. Runtime result is an ordinary
- * Block - the helper is TypeScript salt only.
- */
-export declare function defineEffectBlock<In extends Checkpoint<string>, Out extends Checkpoint<string>>(base: Parameters<typeof defineBlock<In, Out>>[0] & {
-    requires: readonly MemKey<any>[];
-    instanceOptions: NonNullable<Block<In, Out>["instanceOptions"]>;
-}): EffectBlock<In, Out>;
-/** @deprecated Prefer {@link defineEffectBlock} - identical helper. */
-export declare const defineMemEffectBlock: typeof defineEffectBlock;
-/**
- * {@link defineNavBlock} constrained to mem-picked navigation: requires +
- * instanceOptions mandatory, and `click`/`url` should depend on that mem
- * (typically `click: (mem) => …`). Prefer this when the Block opens one of
- * several live rows/items rather than a fixed nav target. Still a Block.
- */
-export declare function defineMemNavBlock<Out extends Checkpoint<string>>(options: NavBlockOptions<Out> & {
-    requires: readonly MemKey<any>[];
-    instanceOptions: NonNullable<Block<Checkpoint<string>, Out>["instanceOptions"]>;
-}): MemNavBlock<Out>;
-/**
- * "Where am I" - reverse-matches a live `page` against every NavBlock /
- * PageBlock in `library`, in order, returning the first one whose own `verify`
- * Traits all pass (its `checkpoint`), or `null` if none match. Deliberately
- * Nav/Page hubs only: each has exactly one fixed `checkpoint` and a `verify`
- * list whose whole job is already "confirm arrival here," so it's a reliable
- * fingerprint - a regular `defineBlock` can branch to different `Out` tags
- * depending on runtime evidence, so its `verify` alone doesn't identify a
- * single state the way a hub's does.
- *
- * The primitive `waygraph auto`'s discovered graph is *for* - the graph says
- * what pages exist and how to reach them; `locate()` is how an autonomous
- * run figures out which one it's actually looking at right now, without a
- * human telling it.
- *
- * More than one NavBlock matching is a real possibility (two Checkpoints
- * whose `verify` Traits are both satisfied by the same page) - `locate()`
- * returns the first match rather than treating that as an error; resolving
- * genuine ambiguity is a follow-up, not solved here.
- * @example const here = await locate(page, [NavLoginBlock, NavDashboardBlock]);
- */
-export declare function locate(page: Page, library: readonly NavBlock<any>[], options?: {
-    timeoutMs?: number;
-}): Promise<string | null>;
-/**
- * Returns a new Block that runs exactly like `block` - same act/observe/resolve,
- * same routing - but with `verify` replaced. For giving one flow stricter (or
- * looser, or just different) confirmation on a Block it didn't author, without
- * that Block needing to have been written as a parameterized factory in
- * anticipation. Same move as `branch()`: decorate an existing Block, don't ask
- * every Block to pre-build its own override mechanism.
- *
- * Wrap the one Block you want to change, in place, wherever it already sits in
- * a `defineFlow([...])` array - every other Block stays untouched:
- * `defineFlow([start, LoginBlock, withVerify(AddToCartBlock, [...]), end])`.
- * There is no separate positional array to keep in sync and no `null`
- * placeholder for "skip this one" - `defineFlow` has no per-slot verify
- * argument at all, only whatever `verify` each Block's own `instruction` (or
- * a `withVerify(...)` wrapping it) carries with it.
- */
-export declare function withVerify<B extends Block<any, any>>(block: B, verify: Trait[] | ((out: any) => Trait[])): B;
-type StubPhaseFn<Out extends Checkpoint<string>> = import("./highlights.js").HighlightStubPhaseOrFn<Out>;
-/**
- * Attach / chain a stubBefore lifecycle on a Block. Prefer
- * `(ctx) => { ctx.ring(...); const x = ctx.mem?.get(Key); }`.
- * @example FillUsernameBlock.stubBefore((ctx) => { ctx.ring("username", { ... }) })
- */
-export declare function withStubBefore<B extends Block<any, any>>(block: B, stub: StubPhaseFn<any>): B;
-/** @see {@link withStubBefore} */
-export declare function withStubAfter<B extends Block<any, any>>(block: B, stub: StubPhaseFn<any>): B;
-/** @see {@link withStubBefore} */
-export declare function withStubOnError<B extends Block<any, any>>(block: B, stub: StubPhaseFn<any>): B;
-/**
- * Replaces one Trait inside `block`'s verify list, leaving every other check
- * untouched - the v1/v2/legacy-variant case, where one check needs a different
- * selector or URL pattern but the rest of the Block is identical. Addressed by
- * the Trait's own `name` (recommended - inserting or reordering other checks
- * can't silently retarget it) or, if you genuinely know the position and don't
- * need that safety, a numeric index. Either way a bad address fails loud
- * immediately instead of quietly doing nothing. `newCheck` can be a bare
- * `check` function (keeps the existing name) or a full `Trait` (to rename too).
- * Only works on a flat `verify` array - a function-form `verify` (from
- * `verify: (out) => Trait[]`) has no fixed list to address into, so this
- * throws rather than guess; use `withVerify` to replace it wholesale instead.
- */
-export declare function modVerify<In extends Checkpoint<string>, Out extends Checkpoint<string>>(block: Block<In, Out>, nameOrIndex: string | number, newCheck: Trait["check"] | Trait): DefinedBlock<In, Out>;
-/**
- * `modVerify`, but for several named checks in one call - a v2 variant that
- * differs in five ways from v1 shouldn't need five nested `modVerify(modVerify(
- * modVerify(...)))` calls to track by eye. `patches` keys are plain strings (a
- * Trait's `name`, not a `MemKey` instance), so an ordinary object literal is
- * fine here - unlike `MemPage`, there's no identity-collision reason to need
- * `[name, check]` pairs. Applies each patch in turn via `modVerify`, so the
- * same fail-loud-on-unknown-name behavior holds for every entry.
- */
-export declare function modVerifyAll<In extends Checkpoint<string>, Out extends Checkpoint<string>>(block: Block<In, Out>, patches: Record<string, Trait["check"] | Trait>): DefinedBlock<In, Out>;
-export {};
+export * from "./engine/config.js";
+export * from "./engine/run-graph.js";
+export * from "./engine/flow.js";
+export * from "./engine/core.js";
+export * from "./engine/compose.js";
+export * from "./engine/engine-class.js";
+export * from "./engine/blocks/nav.js";
+export * from "./engine/blocks/method.js";
+export * from "./engine/blocks/page.js";
+export * from "./engine/blocks/effect.js";
+export * from "./engine/locate.js";