@yagni-app/code-staging 1.2.3-staging.1570.1 → 1.2.3-staging.1580.1

package/dist/extension/prototypeTool.d.ts

@@ -0,0 +1,151 @@
+import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+/**
+ * Prototype tools (Prototypes v1): create, revise, list, and share runnable
+ * single-file HTML impressions of a UI through the token-authed YAGNI Code
+ * proxy (`/api/yagni-code/prototypes`, same contract as the session-authed
+ * `/api/prototypes` — the extension's device token only works on the
+ * yagni-code surface). A Prototype renders live in the app at
+ * `/prototypes/:id` and is throwaway by design: it proposes what to build,
+ * never ships as the build, and touches no product code.
+ *
+ * Sharing from here is the HUMAN path: the developer typed the ask in their own
+ * terminal, so the share is a direct REST call that takes effect immediately
+ * (recorded actor + time, revocable in-app). The agent-in-app path stages a
+ * Decision instead; that lives server-side, not in this client.
+ *
+ * These are single-purpose tools (create/revise/list/share), matching the
+ * extension's one-tool-per-verb idiom (ask_yagni, suggest_next_work, ...).
+ */
+/** Options shared by the four prototype tool factories. */
+export interface MakePrototypeToolOptions {
+    getSessionId?: () => string | undefined;
+    baseUrl: string;
+    getToken: () => string | undefined;
+    fetchImpl?: typeof fetch;
+}
+/** The summary fields of a Prototype the tools read back and print. */
+export interface PrototypeSummary {
+    id: string;
+    title: string;
+    currentRevision: number;
+    /** In-app path stamped by the backend mapper (`/prototypes/:id`). */
+    url: string;
+}
+/** Resolve the backend's in-app path against the base URL so the terminal shows a clickable link. */
+export declare function absoluteUrl(baseUrl: string, url: string): string;
+declare const createParameters: Type.TObject<{
+    title: Type.TString;
+    html: Type.TString;
+    workItemId: Type.TOptional<Type.TString>;
+}>;
+/**
+ * Build the `prototype_create` tool.
+ *
+ * Creates a Prototype from a title and one complete single-file HTML document
+ * and prints the in-app URL where it renders.
+ */
+export declare function makePrototypeCreateTool(opts: MakePrototypeToolOptions): ToolDefinition<typeof createParameters, {
+    prototype: PrototypeSummary | null;
+}>;
+declare const reviseParameters: Type.TObject<{
+    expectedRevision: Type.TOptional<Type.TInteger>;
+    prototypeId: Type.TString;
+    edits: Type.TOptional<Type.TArray<Type.TObject<{
+        find: Type.TString;
+        replace: Type.TString;
+    }>>>;
+    html: Type.TOptional<Type.TString>;
+    note: Type.TOptional<Type.TString>;
+}>;
+/**
+ * Build the `prototype_revise` tool.
+ *
+ * Writes a new revision: targeted `edits` (each `find` must match exactly once
+ * in the current HTML) or a full `html` replacement, with an optional `note`
+ * shown on the revision timeline. A 422 edit miss surfaces as a retryable error
+ * naming the failed find so the model can adjust and call again.
+ */
+export declare function makePrototypeReviseTool(opts: MakePrototypeToolOptions): ToolDefinition<typeof reviseParameters, {
+    prototype: PrototypeSummary | null;
+}>;
+declare const listParameters: Type.TObject<{
+    workItemId: Type.TOptional<Type.TString>;
+}>;
+/**
+ * Build the `prototype_list` tool.
+ *
+ * Lists the workspace's Prototypes (optionally filtered to one work item) with
+ * their current revision and in-app URL.
+ */
+export declare function makePrototypeListTool(opts: MakePrototypeToolOptions): ToolDefinition<typeof listParameters, {
+    prototypes: PrototypeSummary[];
+}>;
+declare const shareParameters: Type.TObject<{
+    prototypeId: Type.TString;
+}>;
+/**
+ * Build the `prototype_share` tool.
+ *
+ * Mints a revocable public share link for a Prototype. This is the HUMAN share
+ * path (the developer asked in their own terminal), so it is a direct REST call
+ * with immediate effect; the in-app agent path stages a Decision instead.
+ */
+export declare function makePrototypeShareTool(opts: MakePrototypeToolOptions): ToolDefinition<typeof shareParameters, {
+    shareUrl: string | null;
+}>;
+declare const readParameters: Type.TObject<{
+    prototypeId: Type.TString;
+    revision: Type.TInteger;
+}>;
+export declare function makePrototypeReadTool(opts: MakePrototypeToolOptions): ToolDefinition<typeof readParameters>;
+declare const draftParameters: Type.TObject<{
+    title: Type.TString;
+    spec: Type.TString;
+    workItemId: Type.TOptional<Type.TString>;
+    automatic: Type.TBoolean;
+    requestKey: Type.TOptional<Type.TString>;
+}>;
+export interface PrototypeDraftResult {
+    status: "created" | "reused" | "skipped" | "failed";
+    prototype?: PrototypeSummary;
+    reference?: {
+        prototypeId: string;
+        revision: number;
+        url?: string;
+        [key: string]: unknown;
+    };
+    reason?: string;
+}
+export declare function draftPrototype(opts: MakePrototypeToolOptions, params: {
+    title: string;
+    spec: string;
+    workItemId?: string;
+    sessionId?: string;
+    automatic: boolean;
+    requestKey?: string;
+}, signal?: AbortSignal): Promise<PrototypeDraftResult>;
+export declare function makePrototypeDraftTool(opts: MakePrototypeToolOptions): ToolDefinition<typeof draftParameters>;
+declare const verificationParameters: Type.TObject<{
+    prototypeId: Type.TString;
+    revision: Type.TInteger;
+    status: Type.TUnion<[Type.TLiteral<"passed">, Type.TLiteral<"failed">, Type.TLiteral<"unverified">]>;
+    summary: Type.TString;
+    checks: Type.TArray<Type.TObject<{
+        name: Type.TString;
+        status: Type.TUnion<[Type.TLiteral<"passed">, Type.TLiteral<"failed">, Type.TLiteral<"unverified">]>;
+        detail: Type.TOptional<Type.TString>;
+    }>>;
+    screenshots: Type.TArray<Type.TObject<{
+        label: Type.TString;
+        url: Type.TString;
+    }>>;
+}>;
+export declare function makePrototypeVerificationTool(opts: MakePrototypeToolOptions): ToolDefinition<typeof verificationParameters>;
+declare const attachParameters: Type.TObject<{
+    prototypeId: Type.TString;
+    workItemId: Type.TString;
+}>;
+export declare function makePrototypeAttachTool(opts: MakePrototypeToolOptions): ToolDefinition<typeof attachParameters>;
+export {};
+//# sourceMappingURL=prototypeTool.d.ts.map

package/dist/extension/prototypeTool.js

@@ -0,0 +1,330 @@
+import { Type } from "typebox";
+import { friendlyFetchError, METERED_POST_FETCH_POLICY, resilientFetch } from "./resilientFetch.js";
+const MAX_FAILED_FIND = 200;
+/** Resolve the backend's in-app path against the base URL so the terminal shows a clickable link. */
+export function absoluteUrl(baseUrl, url) {
+    return /^https?:\/\//.test(url) ? url : `${baseUrl}${url}`;
+}
+function authHeaders(opts) {
+    return {
+        "content-type": "application/json",
+        authorization: `Bearer ${opts.getToken() ?? ""}`,
+    };
+}
+const createParameters = Type.Object({
+    title: Type.String(),
+    html: Type.String(),
+    workItemId: Type.Optional(Type.String()),
+});
+/**
+ * Build the `prototype_create` tool.
+ *
+ * Creates a Prototype from a title and one complete single-file HTML document
+ * and prints the in-app URL where it renders.
+ */
+export function makePrototypeCreateTool(opts) {
+    return {
+        name: "prototype_create",
+        label: "Create prototype",
+        description: "Create a YAGNI Prototype: a runnable, throwaway impression of a UI, rendered live in the " +
+            "YAGNI app. Pass a `title` and the COMPLETE single-file HTML document (inline CSS and JS, " +
+            "no external requests; it runs in a sandboxed iframe). Optionally pass `workItemId` to " +
+            "attach it to the work item it explores. Returns the in-app URL where it renders.",
+        promptSnippet: "prototype_create: create a runnable single-file HTML Prototype in the YAGNI app (returns its URL).",
+        promptGuidelines: [
+            "A Prototype is a single self-contained HTML file: inline all CSS and JS, no external requests.",
+            "Attach the Prototype to the work item it explores via `workItemId` when one is in play.",
+            "Show the user the returned in-app URL so they can open the rendered Prototype.",
+        ],
+        parameters: createParameters,
+        async execute(_toolCallId, params, signal, onUpdate, _ctx) {
+            onUpdate?.({
+                content: [{ type: "text", text: "Creating the Prototype in YAGNI…" }],
+                details: { prototype: null },
+            });
+            const res = await resilientFetch(`${opts.baseUrl}/api/yagni-code/prototypes`, {
+                method: "POST",
+                headers: authHeaders(opts),
+                body: JSON.stringify({
+                    title: params.title,
+                    html: params.html,
+                    sessionId: opts.getSessionId?.(),
+                    ...(params.workItemId ? { workItemId: params.workItemId } : {}),
+                }),
+            }, { fetchImpl: opts.fetchImpl, signal, policy: METERED_POST_FETCH_POLICY });
+            if (!res.ok) {
+                throw new Error(await friendlyFetchError("prototype_create", res));
+            }
+            const data = (await res.json());
+            const url = absoluteUrl(opts.baseUrl, data.prototype.url);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Created Prototype "${data.prototype.title}" (revision ${data.prototype.currentRevision}).\n` +
+                            `Open: ${url}`,
+                    },
+                ],
+                details: { prototype: data.prototype },
+            };
+        },
+    };
+}
+const reviseParameters = Type.Object({
+    expectedRevision: Type.Optional(Type.Integer({ minimum: 1 })),
+    prototypeId: Type.String(),
+    edits: Type.Optional(Type.Array(Type.Object({
+        find: Type.String(),
+        replace: Type.String(),
+    }))),
+    html: Type.Optional(Type.String()),
+    note: Type.Optional(Type.String()),
+});
+/**
+ * Build the `prototype_revise` tool.
+ *
+ * Writes a new revision: targeted `edits` (each `find` must match exactly once
+ * in the current HTML) or a full `html` replacement, with an optional `note`
+ * shown on the revision timeline. A 422 edit miss surfaces as a retryable error
+ * naming the failed find so the model can adjust and call again.
+ */
+export function makePrototypeReviseTool(opts) {
+    return {
+        name: "prototype_revise",
+        label: "Revise prototype",
+        description: "Revise an existing YAGNI Prototype as a new revision. Prefer targeted `edits` (each `find` " +
+            "must match the current HTML exactly once) over sending the full `html` again; pass `html` " +
+            "only for a full replacement. Add a short `note` describing the change; it labels the " +
+            "revision timeline. Returns the in-app URL of the updated Prototype.",
+        promptSnippet: "prototype_revise: apply find/replace edits (or full html) to a Prototype as a new revision.",
+        promptGuidelines: [
+            "Prefer small `edits` over resending full `html`; each `find` must match exactly once.",
+            "If prototype_revise reports a failed find, adjust the find text so it matches exactly once and try again.",
+            "Pass a short `note` with each revision so the design timeline stays readable.",
+        ],
+        parameters: reviseParameters,
+        async execute(_toolCallId, params, signal, onUpdate, _ctx) {
+            onUpdate?.({
+                content: [{ type: "text", text: "Revising the Prototype in YAGNI…" }],
+                details: { prototype: null },
+            });
+            const res = await resilientFetch(`${opts.baseUrl}/api/yagni-code/prototypes/${encodeURIComponent(params.prototypeId)}/revisions`, {
+                method: "POST",
+                headers: authHeaders(opts),
+                body: JSON.stringify({
+                    ...(params.expectedRevision !== undefined ? { expectedRevision: params.expectedRevision } : {}),
+                    ...(params.edits ? { edits: params.edits } : {}),
+                    ...(params.html !== undefined ? { html: params.html } : {}),
+                    ...(params.note ? { note: params.note } : {}),
+                }),
+            }, { fetchImpl: opts.fetchImpl, signal, policy: METERED_POST_FETCH_POLICY });
+            // A 422 is an edit miss, not a transport failure: the backend rejected the
+            // whole batch because one `find` did not match exactly once, and wrote no
+            // revision. Name the failed find so the model can fix it and try again.
+            if (res.status === 422) {
+                let failedFind;
+                try {
+                    const body = (await res.json());
+                    failedFind = body.failedFind;
+                }
+                catch {
+                    /* body unreadable; fall through to the generic message */
+                }
+                const shown = failedFind && failedFind.length > MAX_FAILED_FIND
+                    ? `${failedFind.slice(0, MAX_FAILED_FIND)} ...`
+                    : failedFind;
+                throw new Error("prototype_revise could not apply the edits: each `find` must match exactly once in the " +
+                    `current HTML, and this one did not${shown ? `: "${shown}"` : ""}. No revision was ` +
+                    "written. Adjust the find text (or send the full `html` instead) and try again.");
+            }
+            if (!res.ok) {
+                throw new Error(await friendlyFetchError("prototype_revise", res));
+            }
+            const data = (await res.json());
+            const url = absoluteUrl(opts.baseUrl, data.prototype.url);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Revised Prototype "${data.prototype.title}" to revision ${data.revision.seq}.\n` +
+                            `Open: ${url}`,
+                    },
+                ],
+                details: { prototype: data.prototype },
+            };
+        },
+    };
+}
+const listParameters = Type.Object({
+    workItemId: Type.Optional(Type.String()),
+});
+/**
+ * Build the `prototype_list` tool.
+ *
+ * Lists the workspace's Prototypes (optionally filtered to one work item) with
+ * their current revision and in-app URL.
+ */
+export function makePrototypeListTool(opts) {
+    return {
+        name: "prototype_list",
+        label: "List prototypes",
+        description: "List the workspace's YAGNI Prototypes with their current revision and in-app URL. " +
+            "Optionally pass `workItemId` to list only the Prototypes attached to that work item. " +
+            "Use it to find an existing Prototype to revise instead of creating a duplicate.",
+        promptSnippet: "prototype_list: list the workspace's Prototypes (optionally by work item), with URLs.",
+        promptGuidelines: [
+            "Before creating a Prototype for a work item, call prototype_list to check whether one already exists to revise.",
+        ],
+        parameters: listParameters,
+        async execute(_toolCallId, params, signal, onUpdate, _ctx) {
+            onUpdate?.({
+                content: [{ type: "text", text: "Listing Prototypes…" }],
+                details: { prototypes: [] },
+            });
+            const query = params.workItemId
+                ? `?workItemId=${encodeURIComponent(params.workItemId)}`
+                : "";
+            const res = await resilientFetch(`${opts.baseUrl}/api/yagni-code/prototypes${query}`, { method: "GET", headers: authHeaders(opts) }, { fetchImpl: opts.fetchImpl, signal });
+            if (!res.ok) {
+                throw new Error(await friendlyFetchError("prototype_list", res));
+            }
+            const data = (await res.json());
+            const prototypes = data.prototypes ?? [];
+            const text = prototypes.length === 0
+                ? "No Prototypes found."
+                : prototypes
+                    .map((p) => `- "${p.title}" (revision ${p.currentRevision}): ${absoluteUrl(opts.baseUrl, p.url)}`)
+                    .join("\n");
+            return {
+                content: [{ type: "text", text }],
+                details: { prototypes },
+            };
+        },
+    };
+}
+const shareParameters = Type.Object({
+    prototypeId: Type.String(),
+});
+/**
+ * Build the `prototype_share` tool.
+ *
+ * Mints a revocable public share link for a Prototype. This is the HUMAN share
+ * path (the developer asked in their own terminal), so it is a direct REST call
+ * with immediate effect; the in-app agent path stages a Decision instead.
+ */
+export function makePrototypeShareTool(opts) {
+    return {
+        name: "prototype_share",
+        label: "Share prototype",
+        description: "Mint a public share link for a YAGNI Prototype so someone outside the workspace can view " +
+            "it. Sharing is an explicit act: it records who shared and when, and the link can be " +
+            "revoked from the Prototype's page in the app. Returns the share URL and the in-app URL.",
+        promptSnippet: "prototype_share: mint a revocable public share link for a Prototype.",
+        promptGuidelines: [
+            "Only call prototype_share when the user asks to send a Prototype outside the workspace; sharing is an explicit, recorded act.",
+            "Give the user both links: the share URL to send out and the in-app URL where the share can be revoked.",
+        ],
+        parameters: shareParameters,
+        async execute(_toolCallId, params, signal, onUpdate, _ctx) {
+            onUpdate?.({
+                content: [{ type: "text", text: "Minting a share link…" }],
+                details: { shareUrl: null },
+            });
+            const res = await resilientFetch(`${opts.baseUrl}/api/yagni-code/prototypes/${encodeURIComponent(params.prototypeId)}/share`, { method: "POST", headers: authHeaders(opts) }, { fetchImpl: opts.fetchImpl, signal, policy: METERED_POST_FETCH_POLICY });
+            if (!res.ok) {
+                throw new Error(await friendlyFetchError("prototype_share", res));
+            }
+            const data = (await res.json());
+            const shareUrl = absoluteUrl(opts.baseUrl, data.shareUrl);
+            const inAppUrl = absoluteUrl(opts.baseUrl, `/prototypes/${params.prototypeId}`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Share link minted. Anyone with the link can view this Prototype until it is revoked.\n" +
+                            `Share: ${shareUrl}\n` +
+                            `Open: ${inAppUrl}`,
+                    },
+                ],
+                details: { shareUrl },
+            };
+        },
+    };
+}
+const readParameters = Type.Object({ prototypeId: Type.String(), revision: Type.Integer({ minimum: 1 }) });
+export function makePrototypeReadTool(opts) {
+    return {
+        name: "prototype_read", label: "Read prototype revision",
+        description: "Read the exact prototype revision, HTML, feedback and design provenance. Use the approved revision, never substitute the latest revision.",
+        parameters: readParameters,
+        async execute(_id, params, signal) {
+            const res = await resilientFetch(`${opts.baseUrl}/api/yagni-code/prototypes/${encodeURIComponent(params.prototypeId)}/read?revision=${params.revision}`, { headers: authHeaders(opts) }, { fetchImpl: opts.fetchImpl, signal });
+            if (!res.ok)
+                throw new Error(await friendlyFetchError("prototype_read", res));
+            const data = await res.json();
+            return { content: [{ type: "text", text: JSON.stringify(data) }], details: data };
+        },
+    };
+}
+const draftParameters = Type.Object({
+    title: Type.String(), spec: Type.String(), workItemId: Type.Optional(Type.String()),
+    automatic: Type.Boolean({ default: false }), requestKey: Type.Optional(Type.String()),
+});
+export async function draftPrototype(opts, params, signal) {
+    const res = await resilientFetch(`${opts.baseUrl}/api/yagni-code/prototypes/draft`, {
+        method: "POST", headers: authHeaders(opts), body: JSON.stringify({ ...params, sessionId: params.sessionId ?? opts.getSessionId?.() }),
+    }, { fetchImpl: opts.fetchImpl, signal, policy: METERED_POST_FETCH_POLICY });
+    if (!res.ok)
+        throw new Error(await friendlyFetchError("prototype_draft", res));
+    return await res.json();
+}
+export function makePrototypeDraftTool(opts) {
+    return {
+        name: "prototype_draft", label: "Draft grounded prototype",
+        description: "Draft one private interactive UI prototype using repository design context and synthetic examples. Use for new screens, multi-step flows or uncertain interactions before plan approval. Pass automatic=true only for automatic planning; the server enforces eligibility, feature flag, budget and deduplication. Never replace an approved design. Returns created, reused, skipped or failed with a reason.",
+        parameters: draftParameters,
+        async execute(_id, params, signal) {
+            const data = await draftPrototype(opts, params, signal);
+            return { content: [{ type: "text", text: JSON.stringify(data) }], details: data };
+        },
+    };
+}
+const verificationStatus = Type.Union([Type.Literal("passed"), Type.Literal("failed"), Type.Literal("unverified")]);
+const verificationParameters = Type.Object({
+    prototypeId: Type.String(), revision: Type.Integer({ minimum: 1 }), status: verificationStatus, summary: Type.String(),
+    checks: Type.Array(Type.Object({ name: Type.String(), status: verificationStatus, detail: Type.Optional(Type.String()) })),
+    screenshots: Type.Array(Type.Object({ label: Type.String(), url: Type.String() })),
+});
+export function makePrototypeVerificationTool(opts) {
+    return {
+        name: "prototype_verification", label: "Record design verification",
+        description: "Record observed browser visual and interaction checks against the approved prototype revision. Use credential-free browser tools, compare agreed states, and document intentional departures. Use status=unverified when browser checks are unavailable; never report passed without observed results. Screenshots must be real captured evidence. Build the production UI using repository components, not prototype HTML.",
+        parameters: verificationParameters,
+        async execute(_id, params, signal) {
+            const { prototypeId, ...body } = params;
+            const res = await resilientFetch(`${opts.baseUrl}/api/yagni-code/prototypes/${encodeURIComponent(prototypeId)}/verification`, { method: "POST", headers: authHeaders(opts), body: JSON.stringify(body) }, { fetchImpl: opts.fetchImpl, signal, policy: METERED_POST_FETCH_POLICY });
+            if (!res.ok)
+                throw new Error(await friendlyFetchError("prototype_verification", res));
+            const data = await res.json();
+            return { content: [{ type: "text", text: JSON.stringify(data) }], details: data };
+        },
+    };
+}
+const attachParameters = Type.Object({ prototypeId: Type.String(), workItemId: Type.String() });
+export function makePrototypeAttachTool(opts) {
+    return {
+        name: "prototype_attach", label: "Attach prototype to work item",
+        description: "Attach an existing session prototype to a work item so people can review it beside the plan. The server derives its audience from the work item and revokes existing public links. This does not select a revision or approve a plan.",
+        parameters: attachParameters,
+        async execute(_id, params, signal) {
+            const res = await resilientFetch(`${opts.baseUrl}/api/yagni-code/prototypes/${encodeURIComponent(params.prototypeId)}/attach`, {
+                method: "POST", headers: authHeaders(opts), body: JSON.stringify({ workItemId: params.workItemId }),
+            }, { fetchImpl: opts.fetchImpl, signal, policy: METERED_POST_FETCH_POLICY });
+            if (!res.ok)
+                throw new Error(await friendlyFetchError("prototype_attach", res));
+            const data = await res.json();
+            return { content: [{ type: "text", text: `Attached prototype to work item ${params.workItemId}.` }], details: data };
+        },
+    };
+}
+//# sourceMappingURL=prototypeTool.js.map

package/dist/extension/prototypeVerify.d.ts

@@ -0,0 +1,77 @@
+import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import type { MakePrototypeToolOptions } from "./prototypeTool.js";
+interface Action {
+    action: "click" | "fill";
+    role: string;
+    name: string;
+    value?: string;
+}
+interface Viewport {
+    width: number;
+    height: number;
+}
+interface VerificationInput {
+    prototypeId: string;
+    revision: number;
+    url: string;
+    checks: {
+        name: string;
+        actions?: Action[];
+        expectText: string;
+    }[];
+    viewports?: Viewport[];
+}
+interface VerificationPage {
+    navigate(url: string): Promise<void>;
+    act(action: Action): Promise<void>;
+    hasText(text: string): Promise<boolean>;
+    screenshot(): Promise<Buffer>;
+    close(): Promise<void>;
+}
+export interface VerificationBrowser {
+    open(viewport: Viewport, allowRequest: (url: string) => boolean): Promise<VerificationPage>;
+    close(): Promise<void>;
+}
+interface VerifyOptions extends MakePrototypeToolOptions {
+    launchBrowser?: (cwd: string) => Promise<VerificationBrowser>;
+    timeoutMs?: number;
+}
+type Status = "passed" | "failed" | "unverified";
+interface VerificationResult {
+    revision: number;
+    status: Status;
+    summary: string;
+    checks: {
+        name: string;
+        status: Status;
+        detail?: string;
+    }[];
+    screenshots: {
+        label: string;
+        url: string;
+    }[];
+}
+export declare function verifyPrototype(opts: VerifyOptions, input: VerificationInput, cwd: string, signal?: AbortSignal): Promise<VerificationResult>;
+declare const parameters: Type.TObject<{
+    prototypeId: Type.TString;
+    revision: Type.TInteger;
+    url: Type.TString;
+    checks: Type.TArray<Type.TObject<{
+        name: Type.TString;
+        expectText: Type.TString;
+        actions: Type.TOptional<Type.TArray<Type.TObject<{
+            action: Type.TUnion<[Type.TLiteral<"click">, Type.TLiteral<"fill">]>;
+            role: Type.TString;
+            name: Type.TString;
+            value: Type.TOptional<Type.TString>;
+        }>>>;
+    }>>;
+    viewports: Type.TOptional<Type.TArray<Type.TObject<{
+        width: Type.TInteger;
+        height: Type.TInteger;
+    }>>>;
+}>;
+export declare function makePrototypeVerifyTool(opts: VerifyOptions): ToolDefinition<typeof parameters>;
+export {};
+//# sourceMappingURL=prototypeVerify.d.ts.map