@itmetsam/samurai-framework 0.10.0 → 0.12.1

package/dist/network/router.d.ts

@@ -1,82 +1,9 @@
 import type { ContextTree } from "../browser/context-tree.js";
 import type { BiDiConnector } from "../transport/bidi-connection.js";
-import { type NetworkRequest } from "./network-tracker.js";
+import { type RouteHandler } from "./route.js";
 import { type UrlPattern } from "./url-match.js";
-export type RouteHandler = (route: Route) => void | Promise<void>;
-export interface FulfillOptions {
-    /** @default 200 */
-    status?: number;
-    headers?: Record<string, string>;
-    /** Sets `content-type` unless `headers` has one; `json` implies "application/json" */
-    contentType?: string;
-    body?: string | Buffer;
-    /** Sent as JSON text; cannot be combined with `body` */
-    json?: unknown;
-}
-export interface ContinueOptions {
-    /**
-     * Sends the request to another URL. Firefox applies this to navigations only: the page's `fetch`, XHR and
-     * image requests fail when their URL is changed, so mock those with `fulfill` instead
-     */
-    url?: string;
-    method?: string;
-    /** Replaces all request headers */
-    headers?: Record<string, string>;
-    postData?: string | Buffer;
-}
-interface RouteEntry {
-    pattern: UrlPattern;
-    handler: RouteHandler;
-}
-/** Answers `network.*` commands for one blocked request */
-interface RouteDeps {
-    send: BiDiConnector["send"];
-    /** Passes the request to the next matching route, or lets it continue */
-    next: () => Promise<void>;
-    /** Called once the route is answered, whichever way */
-    settled: (route: Route) => void;
-    /**
-     * Whether a replaced body needs a `content-length` of its own. Firefox keeps the old one and cuts the new body
-     * off; Chrome sets the right one itself and hangs the request when it is given one.
-     */
-    sendsContentLength: boolean;
-}
-/**
- * A request the browser holds until it is answered. Answer it exactly once with `fulfill`, `continue`,
- * `abort` or `fallback`; a second call throws.
- */
-export declare class Route {
-    private readonly info;
-    /** @internal */
-    readonly entry: RouteEntry;
-    private readonly deps;
-    private answered;
-    /** @internal */
-    timer: ReturnType<typeof setTimeout> | undefined;
-    constructor(info: NetworkRequest, 
-    /** @internal */
-    entry: RouteEntry, deps: RouteDeps);
-    request(): NetworkRequest;
-    /** @internal */
-    get isAnswered(): boolean;
-    /** Answers the request without sending it: status 200 and no body unless told otherwise */
-    fulfill(options?: FulfillOptions): Promise<void>;
-    /**
-     * Lets the request go on, optionally changed. `headers` replaces all request headers. A new `postData` brings its
-     * own `content-length` (the request's old one would cut the new body off or leave the server waiting).
-     */
-    continue(options?: ContinueOptions): Promise<void>;
-    /** Makes the request fail (the browser reports a network error to the page) */
-    abort(): Promise<void>;
-    /** Hands the request to the next route that matches it, or lets it continue when there is none */
-    fallback(): Promise<void>;
-    /** @internal Lets the request continue unchanged; failures are logged, not thrown */
-    release(): Promise<void>;
-    /** @internal Fails the request; failures are logged, not thrown */
-    failQuietly(): Promise<void>;
-    private claim;
-    private answer;
-}
+export type { RouteHandler } from "./route.js";
+export { Route } from "./route.js";
 /**
  * Lets a page mock, block and change requests. One `network.addIntercept` serves all routes; matching
  * happens here. Every request the browser holds is answered exactly once, so nothing hangs.
@@ -88,11 +15,7 @@ export declare class Router {
     private routes;
     private pending;
     private failures;
-    private queue;
-    private interceptIds;
-    private currentKey;
-    private currentId;
-    private subscription;
+    private intercept;
     private disposed;
     private routeTimeout;
     constructor(connector: BiDiConnector, tree: ContextTree, contextId: string, options?: {
@@ -108,18 +31,10 @@ export declare class Router {
     /** Lets held requests continue, removes the intercept and stops listening. Idempotent */
     dispose(): Promise<void>;
     private remove;
-    private enqueue;
-    /** Makes the browser-side intercept match the routes: none, one for everything, or one for exact URLs */
-    private sync;
-    /** The exact URLs to block, or undefined to block everything and match here */
-    private urlPatterns;
-    private addIntercept;
-    private removeIntercept;
-    private listen;
-    private stop;
+    /** Makes the browser-side intercept match the routes */
+    private syncIntercept;
     private onBeforeRequestSent;
     /** Runs the `index`-th matching route; past the last one the request continues unchanged */
     private dispatch;
     private record;
 }
-export {};

package/dist/network/router.js

@@ -1,138 +1,13 @@
-import { STATUS_CODES } from "node:http";
 import logger from "../logger/index.js";
-import { BiDiError } from "../transport/bidi-error.js";
-import { toRequest } from "./network-tracker.js";
-import { isExactString, matchUrl, samePattern, } from "./url-match.js";
+import { toRequest } from "./bidi-wire.js";
+import { Intercept } from "./intercept.js";
+import { PendingRoute, } from "./route.js";
+import { matchUrl, samePattern } from "./url-match.js";
+export { Route } from "./route.js";
 /** Time (ms) a handler may take to answer a request before the router lets it continue */
 const DEFAULT_ROUTE_TIMEOUT = 30000;
 /** How many handler errors the router keeps */
 const MAX_ERRORS = 100;
-function toHeaders(headers) {
-    return Object.entries(headers).map(([name, value]) => ({
-        name,
-        value: { type: "string", value },
-    }));
-}
-function toBytes(data) {
-    return typeof data === "string"
-        ? { type: "string", value: data }
-        : { type: "base64", value: data.toString("base64") };
-}
-const hasHeader = (headers, name) => Object.keys(headers).some((key) => key.toLowerCase() === name);
-/**
- * A request the browser holds until it is answered. Answer it exactly once with `fulfill`, `continue`,
- * `abort` or `fallback`; a second call throws.
- */
-export class Route {
-    constructor(info, 
-    /** @internal */
-    entry, deps) {
-        this.info = info;
-        this.entry = entry;
-        this.deps = deps;
-        this.answered = false;
-    }
-    request() {
-        return this.info;
-    }
-    /** @internal */
-    get isAnswered() {
-        return this.answered;
-    }
-    /** Answers the request without sending it: status 200 and no body unless told otherwise */
-    async fulfill(options = {}) {
-        if (options.json !== undefined && options.body !== undefined) {
-            throw new TypeError("route.fulfill(): use either json or body, not both");
-        }
-        const text = options.json !== undefined ? JSON.stringify(options.json) : undefined;
-        const body = options.body ?? text;
-        const headers = { ...options.headers };
-        const contentType = options.contentType ??
-            (text !== undefined ? "application/json" : undefined);
-        if (contentType && !hasHeader(headers, "content-type"))
-            headers["content-type"] = contentType;
-        if (!hasHeader(headers, "content-length")) {
-            headers["content-length"] = String(body === undefined ? 0 : Buffer.byteLength(body));
-        }
-        const status = options.status ?? 200;
-        await this.answer("network.provideResponse", {
-            request: this.info.id,
-            statusCode: status,
-            reasonPhrase: STATUS_CODES[status] ?? "",
-            headers: toHeaders(headers),
-            ...(body !== undefined && { body: toBytes(body) }),
-        });
-    }
-    /**
-     * Lets the request go on, optionally changed. `headers` replaces all request headers. A new `postData` brings its
-     * own `content-length` (the request's old one would cut the new body off or leave the server waiting).
-     */
-    async continue(options = {}) {
-        let headers = options.headers;
-        if (options.postData !== undefined) {
-            const withoutLength = Object.fromEntries(Object.entries(headers ?? this.info.headers).filter(([name]) => name.toLowerCase() !== "content-length"));
-            headers = this.deps.sendsContentLength
-                ? {
-                    ...withoutLength,
-                    "content-length": String(Buffer.byteLength(options.postData)),
-                }
-                : withoutLength;
-        }
-        await this.answer("network.continueRequest", {
-            request: this.info.id,
-            ...(options.url !== undefined && { url: options.url }),
-            ...(options.method !== undefined && { method: options.method }),
-            ...(headers !== undefined && { headers: toHeaders(headers) }),
-            ...(options.postData !== undefined && {
-                body: toBytes(options.postData),
-            }),
-        });
-    }
-    /** Makes the request fail (the browser reports a network error to the page) */
-    async abort() {
-        await this.answer("network.failRequest", { request: this.info.id });
-    }
-    /** Hands the request to the next route that matches it, or lets it continue when there is none */
-    async fallback() {
-        this.claim();
-        await this.deps.next();
-    }
-    /** @internal Lets the request continue unchanged; failures are logged, not thrown */
-    async release() {
-        if (this.answered)
-            return;
-        try {
-            await this.continue();
-        }
-        catch (err) {
-            logger.debug("Could not let %s continue", this.info.url, { err });
-        }
-    }
-    /** @internal Fails the request; failures are logged, not thrown */
-    async failQuietly() {
-        if (this.answered)
-            return;
-        try {
-            await this.abort();
-        }
-        catch (err) {
-            logger.debug("Could not fail %s", this.info.url, { err });
-        }
-    }
-    claim() {
-        if (this.answered)
-            throw new Error("route already handled");
-        this.answered = true;
-        clearTimeout(this.timer);
-        this.deps.settled(this);
-    }
-    async answer(method, params) {
-        this.claim();
-        await this.deps.send(method, params);
-    }
-}
-/** Whether a browser accepts `urlPatterns` in `network.addIntercept`; asked once per connection */
-const patternsUnsupported = new WeakSet();
 /**
  * Lets a page mock, block and change requests. One `network.addIntercept` serves all routes; matching
  * happens here. Every request the browser holds is answered exactly once, so nothing hangs.
@@ -145,8 +20,6 @@ export class Router {
         this.routes = [];
         this.pending = new Set();
         this.failures = [];
-        this.queue = Promise.resolve();
-        this.interceptIds = new Set();
         this.disposed = false;
         this.onBeforeRequestSent = (params) => {
             if (!params.isBlocked || params.context === null)
@@ -154,7 +27,7 @@ export class Router {
             if (!this.tree.isWithin(params.context, this.contextId))
                 return;
             // Held by an intercept of ours, not someone else's
-            if (!(params.intercepts ?? []).some((id) => this.interceptIds.has(id)))
+            if (!this.intercept.holds(params.intercepts))
                 return;
             const info = toRequest(params.request, params.navigation, params.isBlocked, null);
             const matching = this.routes
@@ -163,6 +36,7 @@ export class Router {
             this.dispatch(info, matching, 0).catch((err) => logger.error("Handling the request to %s failed", info.url, { err }));
         };
         this.routeTimeout = options.routeTimeout ?? DEFAULT_ROUTE_TIMEOUT;
+        this.intercept = new Intercept(connector, contextId, this.onBeforeRequestSent);
     }
     /** Errors thrown by route handlers, oldest first */
     get errors() {
@@ -175,7 +49,7 @@ export class Router {
         const entry = { pattern, handler };
         this.routes.push(entry);
         try {
-            await this.enqueue(() => this.sync());
+            await this.syncIntercept();
         }
         catch (err) {
             this.routes = this.routes.filter((route) => route !== entry);
@@ -204,146 +78,47 @@ export class Router {
         this.routes = this.routes.filter((route) => !removed.includes(route));
         // Requests a removed route still holds would wait for nobody
         await Promise.all([...this.pending]
-            .filter((route) => removed.includes(route.entry))
+            .filter((route) => route.entry && removed.includes(route.entry))
             .map((route) => route.release()));
-        await this.enqueue(() => this.sync());
+        await this.syncIntercept();
     }
-    enqueue(work) {
-        const run = this.queue.then(work);
-        this.queue = run.catch(() => undefined);
-        return run;
-    }
-    /** Makes the browser-side intercept match the routes: none, one for everything, or one for exact URLs */
-    async sync() {
-        if (this.routes.length === 0)
-            return this.stop();
-        await this.listen();
-        const patterns = this.urlPatterns();
-        const key = patterns ? JSON.stringify(patterns) : "all";
-        if (key === this.currentKey)
-            return;
-        const id = await this.addIntercept(patterns);
-        const previous = this.currentId;
-        this.currentId = id;
-        this.currentKey =
-            patterns && !patternsUnsupported.has(this.connector) ? key : "all";
-        this.interceptIds.add(id);
-        // The new intercept is in place before the old one goes: nothing slips through in between
-        if (previous !== undefined)
-            await this.removeIntercept(previous);
-    }
-    /** The exact URLs to block, or undefined to block everything and match here */
-    urlPatterns() {
-        if (patternsUnsupported.has(this.connector))
-            return undefined;
-        const patterns = [];
-        for (const { pattern } of this.routes) {
-            // The browser reads a URL string in normal form; anything else could mean something else to it
-            if (!isExactString(pattern) || !isNormalUrl(pattern))
-                return undefined;
-            if (!patterns.some((existing) => existing.type === "string" && existing.pattern === pattern)) {
-                patterns.push({ type: "string", pattern });
-            }
-        }
-        return patterns;
-    }
-    async addIntercept(patterns) {
-        const params = {
-            phases: ["beforeRequestSent"],
-            contexts: [this.contextId],
-        };
-        try {
-            const { intercept } = await this.connector.send("network.addIntercept", {
-                ...params,
-                ...(patterns && { urlPatterns: patterns }),
-            });
-            return intercept;
-        }
-        catch (err) {
-            if (patterns &&
-                err instanceof BiDiError &&
-                err.code === "invalid argument") {
-                patternsUnsupported.add(this.connector);
-                return this.addIntercept(undefined);
-            }
-            throw err;
-        }
-    }
-    async removeIntercept(id) {
-        try {
-            await this.connector.send("network.removeIntercept", { intercept: id });
-        }
-        catch (err) {
-            if (!(err instanceof BiDiError && err.code === "no such intercept"))
-                throw err;
-        }
-        finally {
-            this.interceptIds.delete(id);
-        }
-    }
-    async listen() {
-        if (this.subscription)
-            return;
-        this.connector.onEvent("network.beforeRequestSent", this.onBeforeRequestSent);
-        try {
-            this.subscription = await this.connector.subscribe([
-                "network.beforeRequestSent",
-            ]);
-        }
-        catch (err) {
-            this.connector.offEvent("network.beforeRequestSent", this.onBeforeRequestSent);
-            throw err;
-        }
-    }
-    async stop() {
-        const id = this.currentId;
-        this.currentId = undefined;
-        this.currentKey = undefined;
-        if (id !== undefined)
-            await this.removeIntercept(id);
-        if (this.subscription) {
-            this.connector.offEvent("network.beforeRequestSent", this.onBeforeRequestSent);
-            const subscription = this.subscription;
-            this.subscription = undefined;
-            await subscription.unsubscribe();
-        }
+    /** Makes the browser-side intercept match the routes */
+    syncIntercept() {
+        return this.intercept.sync(this.routes.map((route) => route.pattern));
     }
     /** Runs the `index`-th matching route; past the last one the request continues unchanged */
     async dispatch(info, matching, index) {
         const entry = matching[index];
-        const deps = {
+        const control = {
             send: (method, params) => this.connector.send(method, params),
             next: () => this.dispatch(info, matching, index + 1),
-            settled: (settled) => {
+            onSettled: (settled) => {
                 this.pending.delete(settled);
             },
             sendsContentLength: this.connector.browserName !== "chrome",
         };
         if (!entry) {
             // Nobody (left) to ask: an unmatched request, or every route fell back
-            await new Route(info, { pattern: "", handler: () => { } }, deps).release();
+            await new PendingRoute(info, control).release();
             return;
         }
-        const route = new Route(info, entry, deps);
-        this.pending.add(route);
-        route.timer = setTimeout(() => {
-            if (route.isAnswered)
-                return;
+        const pending = new PendingRoute(info, control, entry);
+        this.pending.add(pending);
+        pending.startTimer(this.routeTimeout, () => {
             logger.error("A route for %s did not answer within %dms; letting the request continue", info.url, this.routeTimeout);
-            void route.release();
-        }, this.routeTimeout);
-        route.timer.unref?.();
+            void pending.release();
+        });
         try {
-            await entry.handler(route);
+            await entry.handler(pending.route);
         }
         catch (err) {
             this.record(info, err);
-            await route.failQuietly();
+            await pending.failQuietly();
             return;
         }
-        if (!route.isAnswered) {
+        if (!pending.isAnswered) {
             logger.warn("The route for %s did not answer the request; letting it continue", info.url);
-            await route.release();
+            await pending.release();
         }
     }
     record(info, err) {
@@ -355,11 +130,3 @@ export class Router {
         logger.error("A route handler threw for %s", info.url, { err });
     }
 }
-function isNormalUrl(value) {
-    try {
-        return new URL(value).href === value;
-    }
-    catch {
-        return false;
-    }
-}

package/dist/recorder/expectation.d.ts

@@ -0,0 +1,5 @@
+import type { Expectation } from "../steps/model.js";
+/** The name a secret gets in `secrets.<NAME>`: the field's name or id, upper snake case */
+export declare function secretNameFor(hint: string | undefined): string;
+/** The assertion an Alt+click or a pick starts with: the value of a field, else the text (cut when long), else visible */
+export declare function expectationFor(text: string, value: string | undefined): Expectation;

package/dist/recorder/expectation.js

@@ -0,0 +1,20 @@
+const TEXT_LIMIT = 100;
+/** The name a secret gets in `secrets.<NAME>`: the field's name or id, upper snake case */
+export function secretNameFor(hint) {
+    const name = (hint ?? "")
+        .replace(/([a-z\d])([A-Z])/g, "$1_$2")
+        .replace(/[^A-Za-z0-9]+/g, "_")
+        .replace(/^_+|_+$/g, "")
+        .toUpperCase();
+    return name === "" || /^\d/.test(name) ? "PASSWORD" : name;
+}
+/** The assertion an Alt+click or a pick starts with: the value of a field, else the text (cut when long), else visible */
+export function expectationFor(text, value) {
+    if (value !== undefined)
+        return { matcher: "toHaveValue", expected: value };
+    if (text === "")
+        return { matcher: "toBeVisible" };
+    return text.length <= TEXT_LIMIT
+        ? { matcher: "toHaveText", expected: text }
+        : { matcher: "toContainText", expected: text.slice(0, TEXT_LIMIT).trim() };
+}

package/dist/recorder/files-recorder.d.ts

@@ -0,0 +1,30 @@
+import type { BiDiConnector } from "../transport/bidi-connection.js";
+import type { FileRecording, MissingFile } from "./options.js";
+/** The warning for a file that isn't saved, as the toolbar and the CLI show it */
+export declare function missingFileText(file: MissingFile, folder: string): string;
+/** What `FilesRecorder` tells the toolbar, when there is one */
+export interface FilesNotices {
+    warn(text: string): void;
+    /** A file is being saved; `undefined` when done */
+    saving(name: string | undefined): void;
+}
+/** Saves the files a person picked or dropped into the project's files folder and keeps count of what was and was not saved */
+export declare class FilesRecorder {
+    private readonly connector;
+    private readonly context;
+    private readonly recording;
+    private readonly notices;
+    private readonly stored;
+    private readonly missing;
+    constructor(connector: BiDiConnector, context: string, recording: FileRecording, notices: FilesNotices);
+    /** Files stored or reused in the files folder by this recording, project-relative */
+    get storedFiles(): string[];
+    /** Files whose steps point at a path that wasn't written */
+    get missingFiles(): MissingFile[];
+    /** Saves one kept file to the files folder; returns the path its step gets */
+    store(file: {
+        id: number;
+        name: string;
+        size: number;
+    }): Promise<string>;
+}

package/dist/recorder/files-recorder.js

@@ -0,0 +1,88 @@
+import { mkdtemp, open, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import logger from "../logger/index.js";
+import { cleanFileName, filesFolder, RECORD_LIMIT, storeFile, } from "../project/index.js";
+import { humanSize } from "../steps/files.js";
+import { readPageFile, releasePageFile } from "./files-reader.js";
+/** The warning for a file that isn't saved, as the toolbar and the CLI show it */
+export function missingFileText(file, folder) {
+    const where = folder === "" ? "the project folder" : `${folder}/`;
+    return file.reason === "too-big"
+        ? `${file.name} is ${humanSize(file.size)}. Files over 50 MB aren't saved: add it to ${where} yourself, or use a generated file.`
+        : `${file.name} couldn't be read, so it isn't saved: add it to ${where} yourself, or use a generated file.`;
+}
+/** Saves the files a person picked or dropped into the project's files folder and keeps count of what was and was not saved */
+export class FilesRecorder {
+    constructor(connector, context, recording, notices) {
+        this.connector = connector;
+        this.context = context;
+        this.recording = recording;
+        this.notices = notices;
+        this.stored = new Set();
+        this.missing = [];
+    }
+    /** Files stored or reused in the files folder by this recording, project-relative */
+    get storedFiles() {
+        return [...this.stored];
+    }
+    /** Files whose steps point at a path that wasn't written */
+    get missingFiles() {
+        return [...this.missing];
+    }
+    /** Saves one kept file to the files folder; returns the path its step gets */
+    async store(file) {
+        const recording = this.recording;
+        const folder = filesFolder(recording.projectDir, recording.filesDir);
+        const notSaved = (reason) => {
+            const clean = cleanFileName(file.name);
+            const missing = {
+                path: folder.relative ? `${folder.relative}/${clean}` : clean,
+                name: file.name,
+                size: file.size,
+                reason,
+            };
+            this.missing.push(missing);
+            recording.onMissing?.(missing);
+            this.notices.warn(missingFileText(missing, folder.relative));
+            return missing.path;
+        };
+        if (file.size > RECORD_LIMIT) {
+            await releasePageFile(this.connector, this.context, file.id).catch(() => undefined);
+            return notSaved("too-big");
+        }
+        this.notices.saving(file.name);
+        let temp;
+        try {
+            temp = await mkdtemp(path.join(tmpdir(), "samurai-upload-"));
+            const content = path.join(temp, "content");
+            const out = await open(content, "w");
+            try {
+                await readPageFile(this.connector, this.context, file.id, file.size, (bytes) => out.write(bytes));
+            }
+            finally {
+                await out.close();
+            }
+            const stored = await storeFile({
+                projectDir: recording.projectDir,
+                ...(recording.filesDir !== undefined && {
+                    filesDir: recording.filesDir,
+                }),
+                name: file.name,
+                content,
+            });
+            this.stored.add(stored.path);
+            return stored.path;
+        }
+        catch (err) {
+            logger.warn("Recorder could not save %s", file.name, { err });
+            return notSaved("unreadable");
+        }
+        finally {
+            this.notices.saving(undefined);
+            if (temp)
+                await rm(temp, { recursive: true, force: true }).catch(() => undefined);
+            await releasePageFile(this.connector, this.context, file.id).catch(() => undefined);
+        }
+    }
+}

package/dist/recorder/normalise.d.ts

@@ -76,7 +76,7 @@ export type Observation = {
     type: "goto";
     url: string;
 };
-export interface NormaliserOptions {
+interface NormaliserOptions {
     /** Index the first recorded step gets */
     at: number;
     /** Relative URLs are written against this */
@@ -84,11 +84,6 @@ export interface NormaliserOptions {
     /** A navigation within this many ms of the last action is a consequence of it. @default 2000 */
     navigationWindow?: number;
 }
-/** A picker that opens within this many ms of a click was opened by it */
-export declare const PICKER_WINDOW = 1000;
-/** The name a secret gets in `secrets.<NAME>`: the field's name or id, upper snake case */
-export declare function secretNameFor(hint: string | undefined): string;
-export declare function expectationFor(text: string, value: string | undefined): Expectation;
 /**
  * Turns what the tester did into steps:
  * - typing into a field becomes one `fill`, rewritten as the text grows (a password becomes a secret reference);
@@ -117,8 +112,24 @@ export declare class Normaliser {
     /** Steps the toolbar asks for directly; undefined for page observations */
     private toolbarStep;
     observe(observation: Observation, at: number): RecorderEvent[];
+    /**
+     * The sandbox reports a picker for any click on a file input, including ones a page script fires: it is only a
+     * hint, and only the very last step, recorded just before, may be replaced or removed (a page's own
+     * input.click() also counts as the opening click, bounded to the last step within PICKER_WINDOW)
+     */
+    private pickerOpened;
+    /** The picker closed without a choice: the click that opened it is taken out again */
+    private pickerCancelled;
+    private filesSet;
+    private clicked;
+    private pressed;
+    /** An Alt+click */
+    private asserted;
+    /** Typing: one `fill` per field, rewritten as the text grows */
+    private typed;
     /** A top-level navigation started */
     navigated(url: string, at: number): RecorderEvent[];
     /** The page the recording starts on, written as a `goto` */
     initialGoto(url: string): RecorderEvent[];
 }
+export {};