waygraph 0.15.54 → 0.16.1

package/dist/commands/traverse.js

@@ -1,177 +0,0 @@
-// Split out of the former 8,700-line cli.ts (see src/ARCHITECTURE.md). Behavior unchanged.
-import { resolve } from "node:path";
-import { existsSync, statSync } from "node:fs";
-import { parseBlocksSelect } from "../blocks-select.js";
-import { parseMinEdgeCoverage } from "../traverse/coverage.js";
-import { runTraverse } from "../traverse/run.js";
-export async function traverseCase(args) {
-    if (args.includes("--step") || args.includes("--auto-next") || args.includes("--autoplay")) {
-        console.error("waygraph traverse: --step / --auto-next not supported (not a demo)");
-        process.exit(1);
-    }
-    const rest = args.slice(1);
-    let from;
-    let data;
-    let maxSteps;
-    let maxVisits;
-    let maxEdge;
-    let headed = false;
-    let baseUrl;
-    let blocksFilter;
-    let parallel;
-    let session;
-    let minEdgeCoverageRaw;
-    let coverageOut;
-    let noCoverageReport = false;
-    let projectDir = process.cwd();
-    for (let i = 0; i < rest.length; i++) {
-        const a = rest[i];
-        if (a === "--from" || a.startsWith("--from=")) {
-            from = a.startsWith("--from=") ? a.slice(7) : rest[++i];
-            continue;
-        }
-        if (a === "--data" || a.startsWith("--data=")) {
-            data = a.startsWith("--data=") ? a.slice(7) : rest[++i];
-            continue;
-        }
-        if (a === "--blocks" || a.startsWith("--blocks=")) {
-            if (a.startsWith("--blocks=")) {
-                blocksFilter = a.slice("--blocks=".length);
-            }
-            else {
-                const v = rest[++i];
-                if (!v || v.startsWith("-")) {
-                    console.error("waygraph traverse: --blocks needs a glob, /regex/, or path substring");
-                    process.exit(1);
-                }
-                blocksFilter = v;
-            }
-            continue;
-        }
-        if (a === "--parallel" || a.startsWith("--parallel=")) {
-            const v = a.startsWith("--parallel=") ? a.slice("--parallel=".length) : rest[++i];
-            parallel = Number(v);
-            continue;
-        }
-        if (a === "--session" || a.startsWith("--session=")) {
-            const v = a.startsWith("--session=") ? a.slice("--session=".length) : rest[++i];
-            if (v !== "clone" && v !== "inherit") {
-                console.error('waygraph traverse: --session must be "clone" or "inherit"');
-                process.exit(1);
-            }
-            session = v;
-            continue;
-        }
-        if (a === "--min-edge-coverage" || a.startsWith("--min-edge-coverage=")) {
-            minEdgeCoverageRaw = a.startsWith("--min-edge-coverage=")
-                ? a.slice("--min-edge-coverage=".length)
-                : rest[++i];
-            continue;
-        }
-        if (a === "--coverage-out" || a.startsWith("--coverage-out=")) {
-            coverageOut = a.startsWith("--coverage-out=")
-                ? a.slice("--coverage-out=".length)
-                : rest[++i];
-            continue;
-        }
-        if (a === "--no-coverage-report") {
-            noCoverageReport = true;
-            continue;
-        }
-        if (a === "--max-steps" || a.startsWith("--max-steps=")) {
-            const v = a.startsWith("--max-steps=") ? a.slice(12) : rest[++i];
-            maxSteps = Number(v);
-            continue;
-        }
-        if (a === "--max-visits" || a.startsWith("--max-visits=")) {
-            const v = a.startsWith("--max-visits=") ? a.slice(13) : rest[++i];
-            maxVisits = Number(v);
-            continue;
-        }
-        if (a === "--max-visits-per-edge" || a.startsWith("--max-visits-per-edge=")) {
-            const v = a.startsWith("--max-visits-per-edge=")
-                ? a.slice("--max-visits-per-edge=".length)
-                : rest[++i];
-            maxEdge = Number(v);
-            continue;
-        }
-        if (a === "--non-headless" || a === "--headed") {
-            headed = true;
-            continue;
-        }
-        if (a === "--base-url" || a.startsWith("--base-url=")) {
-            baseUrl = a.startsWith("--base-url=") ? a.slice(11) : rest[++i];
-            continue;
-        }
-        if (a === "--help" || a === "-h") {
-            console.log(`waygraph traverse [project] [flags]
-
-Graph crawl (RFC Phase B-E). Walks unused legal edges until a leaf,
-budget kill, or first broken edge. --parallel N uses session clone + edge leases.
-
-  --blocks <glob|/regex/|substr>  Phase C: filter *.block.ts discovery
-  --parallel N            Phase D: N clone workers (default 1, max 4)
-  --session clone|inherit Phase D: default clone; inherit refused if parallel>1
-  --min-edge-coverage X   Phase E: suite gate 0.8 | 80% | 80 (exit 2 if below)
-  --coverage-out PATH     Phase E: write JSON (default .waygraph-traverse/coverage.json)
-  --no-coverage-report    Phase E: print Coverage line only (no JSON file)
-  --from <Checkpoint>     start checkpoint (optional)
-  --data '{...}'          Mem seed JSON
-  --max-steps N           default 50 (per worker)
-  --max-visits N          per-node visit cap (default 2)
-  --max-visits-per-edge N default 1
-  --non-headless          show browser
-  --base-url URL
-
-Examples:
-  waygraph traverse --blocks '**/mailpit/**/*.block.ts'
-  waygraph traverse --parallel 2 --session clone --max-steps 20
-  waygraph traverse --min-edge-coverage 80% --coverage-out ./cov.json
-
-PASS:  [Reached Leaf Node[traverse-1] at=... steps=N]
-FAIL:  [Broke at edge[traverse-1] block=... from=... to=...]
-COVER: [Coverage edges=H/T ratio=R% min=M% PASS|FAIL]
-`);
-            process.exit(0);
-        }
-        if (!a.startsWith("-")) {
-            projectDir = resolve(a);
-        }
-    }
-    if (!existsSync(projectDir) || !statSync(projectDir).isDirectory()) {
-        console.error(`waygraph traverse: no such directory: ${projectDir}`);
-        process.exit(1);
-    }
-    const blocksSelect = blocksFilter
-        ? parseBlocksSelect(blocksFilter)
-        : undefined;
-    let minEdgeCoverage;
-    if (minEdgeCoverageRaw !== undefined) {
-        const parsed = parseMinEdgeCoverage(minEdgeCoverageRaw);
-        if (parsed === null) {
-            console.error(`waygraph traverse: --min-edge-coverage expects 0.8, 80%, or 80 (got ${JSON.stringify(minEdgeCoverageRaw)})`);
-            process.exit(1);
-        }
-        minEdgeCoverage = parsed;
-    }
-    const code = await runTraverse(projectDir, {
-        ...(from ? { from } : {}),
-        ...(data ? { data } : {}),
-        ...(maxSteps !== undefined && Number.isFinite(maxSteps) ? { maxSteps } : {}),
-        ...(maxVisits !== undefined && Number.isFinite(maxVisits)
-            ? { maxVisitsPerNode: maxVisits }
-            : {}),
-        ...(maxEdge !== undefined && Number.isFinite(maxEdge)
-            ? { maxVisitsPerEdge: maxEdge }
-            : {}),
-        headed,
-        ...(baseUrl ? { baseURL: baseUrl } : {}),
-        ...(blocksSelect ? { blocksSelect } : {}),
-        ...(parallel !== undefined && Number.isFinite(parallel) ? { parallel } : {}),
-        ...(session ? { session } : {}),
-        ...(minEdgeCoverage !== undefined ? { minEdgeCoverage } : {}),
-        ...(coverageOut ? { coverageOut: resolve(coverageOut) } : {}),
-        ...(noCoverageReport ? { noCoverageReport: true } : {}),
-    });
-    process.exit(code);
-}

package/dist/core/block.d.ts

@@ -1,109 +0,0 @@
-import type { ActionPage, Block, Checkpoint, DefinedBlock, Instruction } from "../types.js";
-import { MemPage } from "../mem-page.js";
-import type { MemKey } from "../mem-page.js";
-import type { Trait } from "../trait.js";
-export declare function findBlockIndex(middle: readonly Block<any, any>[], block: Block<any, any> | string | number): number;
-/**
- * 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>;
-/** Copy non-enumerable waygraph markers so decorate/withVerify keep map() kind checks. */
-export declare function copyWaygraphRuntime(from: object, to: object): void;
-/**
- * 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>;
-/**
- * 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", { ... }) })
- * @deprecated Use the chained method: `Block.stubBefore((ctx) => …)`.
- */
-export declare function withStubBefore<B extends Block<any, any>>(block: B, stub: StubPhaseFn<any>): B;
-/** @see {@link withStubBefore}  * @deprecated Use the chained method: `Block.stubAfter((ctx) => …)`.
- */
-export declare function withStubAfter<B extends Block<any, any>>(block: B, stub: StubPhaseFn<any>): B;
-/** @see {@link withStubBefore}  * @deprecated Use the chained method: `Block.stubOnError((ctx) => …)`.
- */
-export declare function withStubOnError<B extends Block<any, any>>(block: B, stub: StubPhaseFn<any>): B;
-/**
- * Answers the browser's own dialog (`confirm`, `alert`, `prompt`, `beforeunload`) that this Block's action
- * triggers. A dialog freezes the page until it is answered, so the answer has to be armed before the click -
- * this does that without folding it into the Block's own `act`. The dialog's text can be kept in mem.
- * @example withDialog(CancelBlock, { accept: true, into: LeaveWarning })
- */
-export declare function withDialog<B extends Block<any, any>>(block: B, options?: {
-    accept?: boolean;
-    into?: MemKey<string>;
-    promptText?: string;
-}): 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 {};

package/dist/core/blocks/effect.js

@@ -1,23 +0,0 @@
-import { defineBlock } from "../block.js";
-/**
- * {@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 function defineEffectBlock(base) {
-    const built = defineBlock(base);
-    Object.defineProperty(built, "__waygraphMemKind", {
-        value: "effect",
-        enumerable: false,
-        configurable: false,
-    });
-    Object.defineProperty(built, "__waygraphSalt", {
-        value: "effect",
-        enumerable: false,
-        configurable: false,
-    });
-    return built;
-}
-/** @deprecated Prefer {@link defineEffectBlock} - identical helper. */
-export const defineMemEffectBlock = defineEffectBlock;

package/dist/core/config.js

@@ -1,17 +0,0 @@
-// Split out of the former 2,900-line engine.ts (see src/ARCHITECTURE.md). Behavior unchanged.
-import { chromium, firefox, webkit } from "@playwright/test";
-const LAUNCHERS = { chromium, firefox, webkit };
-/**
- * Resolves which `BrowserType` actually launches for a `mem`-only run (no
- * caller-supplied context) - `config.browsers[browserName]` if given,
- * otherwise the real `@playwright/test` export. Waygraph is deliberately
- * "just an opinionated Playwright" - it doesn't own browser automation
- * itself, so it shouldn't force every consumer onto the vanilla launcher.
- * A stealth-patched or otherwise customized launcher (e.g. `playwright-extra`
- * plus a stealth plugin) is a drop-in replacement for `chromium`/`firefox`/
- * `webkit` - same `.launch()` shape - so accepting one here costs nothing for
- * a consumer who never sets it.
- */
-export function resolveLauncher(browserName, config) {
-    return config?.browsers?.[browserName] ?? LAUNCHERS[browserName];
-}

package/dist/core/engine.d.ts

@@ -1,198 +0,0 @@
-import type { Block, Checkpoint } from "../types.js";
-import type { EngineConfig } from "./config.js";
-import type { EndMarker, StartMarker } from "./run-graph.js";
-import type { Flow, FlowOptions } from "./flow.js";
-import { MapBuilder } from "./map-builder.js";
-import type { MapBuilderOptions } from "./map-builder.js";
-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);
-    /**
-     * @deprecated Build flows with `engine.map()`, which checks each step's Block kind and nests flows with `.flow()`.
-     *
-     * 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.
-     * Options go in the second argument instead of wrapping the result in `withTitle(withMemStub(...))`.
-     * @example engine.defineFlow([start, LoginBlock, AddToCartBlock, end], { title: "Login", memStub: true })
-     */
-    defineFlow<B extends Checkpoint<string>>(blocks: readonly [StartMarker, Block<S, B>, EndMarker], options?: FlowOptions): Flow<B>;
-    defineFlow<B extends Checkpoint<string>, C extends Checkpoint<string>>(blocks: readonly [StartMarker, Block<S, B>, Block<B, C>, EndMarker], options?: FlowOptions): 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], options?: FlowOptions): 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], options?: FlowOptions): 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
-    ], options?: FlowOptions): 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
-    ], options?: FlowOptions): 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
-    ], options?: FlowOptions): 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
-    ], options?: FlowOptions): 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
-    ], options?: FlowOptions): 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
-    ], options?: FlowOptions): 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
-    ], options?: FlowOptions): 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
-    ], options?: FlowOptions): 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
-    ], options?: FlowOptions): 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
-    ], options?: FlowOptions): 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>;
-}
-/**
- * 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>;
-export {};