@paikko/contract 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1590 @@
+/**
+ * paikko ticket bundle contract.
+ *
+ * This is THE shared interface. Every module imports from here: the
+ * `<ReportButton>` that produces a bundle, the API that persists it, the ticket
+ * UI that renders it, and the agent runner that consumes it. Change a shape here
+ * and you change it for everyone, so it lives in one file with types and zod
+ * schemas side by side.
+ *
+ * ## Two tiers
+ *
+ * A ticket is split so the agent's context stays cheap:
+ *
+ *   - TIER 1 - the HEAD ({@link TicketHead}). Small, always loaded into agent
+ *     context. Carries the user's message, where it happened (route + clicked
+ *     element provenance), the conversation thread, and an INDEX of artifacts.
+ *     The index lists each artifact by name with a `ref` (how to fetch it) and a
+ *     `summary` (one line) plus a few cheap stats, so the agent can decide from
+ *     the head alone whether it even needs the heavy payload. Most tickets are
+ *     solved from the head with zero fetches.
+ *
+ *   - TIER 2 - the ARTIFACT PAYLOADS. Heavy, immutable, captured once at report
+ *     time (a photograph, not a live window). Fetched by ref only when a fix
+ *     needs them: console, network, client state, storage, DOM snapshot, backend
+ *     trace. Stored as JSONB rows keyed by ticket+name, served at
+ *     `GET /tickets/:id/artifacts/:name`.
+ *
+ * ## The spine: traceId
+ *
+ * `traceId` stitches the two halves of a single request together. A frontend
+ * {@link NetworkEntry} and the backend {@link TraceRequest} it triggered share
+ * the same `traceId`. That is how the agent walks from "this fetch on the page"
+ * to "this handler + these queries on the server" without guessing.
+ *
+ * ## Provenance: src
+ *
+ * `src` ("file:line:col") appears on every layer the user or agent can point at -
+ * the clicked element, the API handler, each DB query - so provenance runs end to
+ * end. It is injected at build time (see PROVENANCE.md).
+ */
+import { z } from "zod";
+/**
+ * Ticket lifecycle. `status` is persisted as a free `String` in
+ * prisma/schema.prisma; this enum is the app-side validator for it.
+ *
+ * Terminal states are `closed` (accepted: the ticket's branch was merged to main
+ * and the live app redeployed) and `rejected` (discarded: the ticket's branch +
+ * worktree were dropped, the live app untouched). `reviewing` is the parked state
+ * where the fix lives on its own branch with an isolated preview; a user reply on
+ * a `reviewing` ticket re-engages the agent (no separate reject needed to request
+ * changes).
+ */
+export declare const TicketStatusSchema: z.ZodEnum<["open", "reproducing", "needs_info", "reviewing", "closed", "rejected"]>;
+export type TicketStatus = z.infer<typeof TicketStatusSchema>;
+/**
+ * The canonical names an artifact can have. The artifact index is keyed by these,
+ * and `GET /tickets/:id/artifacts/:name` expects one of them.
+ */
+export declare const ArtifactNameSchema: z.ZodEnum<["console", "network", "clientState", "storage", "dom", "trace", "screenshot"]>;
+export type ArtifactName = z.infer<typeof ArtifactNameSchema>;
+/**
+ * Source provenance, "file:line:col" (e.g. "src/components/Cart.tsx:42:7").
+ * Injected at build time onto JSX, attached to handlers and queries.
+ */
+export declare const SrcSchema: z.ZodString;
+export type Src = z.infer<typeof SrcSchema>;
+/** ISO-8601 timestamp string. Used everywhere a time is recorded. */
+export declare const IsoTimeSchema: z.ZodString;
+export type IsoTime = z.infer<typeof IsoTimeSchema>;
+/**
+ * The id that stitches a frontend network entry to its backend request.
+ * Generated client-side per request, echoed by the server.
+ */
+export declare const TraceIdSchema: z.ZodString;
+export type TraceId = z.infer<typeof TraceIdSchema>;
+/**
+ * What the user pointed at when they hit report: the clicked DOM element resolved
+ * to a CSS selector, its source location, and the owning component. All optional
+ * because a report can be fired without a specific target (e.g. a global "this
+ * page is wrong").
+ */
+export declare const ReportTargetSchema: z.ZodObject<{
+    /** CSS selector identifying the clicked element in the live DOM. */
+    selector: z.ZodNullable<z.ZodString>;
+    /** Build-time source provenance of the element ("file:line:col"). */
+    src: z.ZodNullable<z.ZodString>;
+    /** Display name of the React component that owns the element. */
+    component: z.ZodNullable<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    selector: string | null;
+    src: string | null;
+    component: string | null;
+}, {
+    selector: string | null;
+    src: string | null;
+    component: string | null;
+}>;
+export type ReportTarget = z.infer<typeof ReportTargetSchema>;
+/** The user-authored core of a report: what's wrong and where. */
+export declare const ReportSchema: z.ZodObject<{
+    /** Free-text description from the reporter. Capped so a single report can't be
+     * an unbounded blob (intake has no other size gate on this field). */
+    message: z.ZodString;
+    /** Report category (e.g. "bug", "visual", "crash"). Free-form in v0. */
+    kind: z.ZodString;
+    /** App route the report was fired from (e.g. "/cart"). */
+    route: z.ZodString;
+    /** The clicked element, resolved to selector + provenance + component. */
+    target: z.ZodObject<{
+        /** CSS selector identifying the clicked element in the live DOM. */
+        selector: z.ZodNullable<z.ZodString>;
+        /** Build-time source provenance of the element ("file:line:col"). */
+        src: z.ZodNullable<z.ZodString>;
+        /** Display name of the React component that owns the element. */
+        component: z.ZodNullable<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        selector: string | null;
+        src: string | null;
+        component: string | null;
+    }, {
+        selector: string | null;
+        src: string | null;
+        component: string | null;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    kind: string;
+    route: string;
+    target: {
+        selector: string | null;
+        src: string | null;
+        component: string | null;
+    };
+}, {
+    message: string;
+    kind: string;
+    route: string;
+    target: {
+        selector: string | null;
+        src: string | null;
+        component: string | null;
+    };
+}>;
+export type Report = z.infer<typeof ReportSchema>;
+/** One message in the ticket's conversation (reporter, agent, or reviewer). */
+export declare const ThreadMessageSchema: z.ZodObject<{
+    id: z.ZodString;
+    /** Author handle: reporter id, "agent", reviewer id, etc. */
+    by: z.ZodString;
+    text: z.ZodString;
+    at: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    at: string;
+    id: string;
+    by: string;
+    text: string;
+}, {
+    at: string;
+    id: string;
+    by: string;
+    text: string;
+}>;
+export type ThreadMessage = z.infer<typeof ThreadMessageSchema>;
+/**
+ * One entry in the artifact index. Lives in the head so the agent can read the
+ * `summary` and stats and decide whether to fetch the heavy payload via `ref`.
+ *
+ * `count` and `size` are cheap, type-agnostic stats:
+ *   - `count`: number of records in the payload (console lines, network calls,
+ *     backend requests, ...). Null for single-object artifacts (clientState).
+ *   - `size`: serialized payload size in bytes.
+ */
+export declare const ArtifactIndexEntrySchema: z.ZodObject<{
+    /** Fetch handle: `GET /tickets/:id/artifacts/:name`. */
+    ref: z.ZodString;
+    /** One-line human/agent summary so the head is decision-complete. */
+    summary: z.ZodString;
+    /** Record count for collection artifacts; null for singletons. */
+    count: z.ZodNullable<z.ZodNumber>;
+    /** Serialized payload size in bytes. */
+    size: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    ref: string;
+    summary: string;
+    count: number | null;
+    size: number;
+}, {
+    ref: string;
+    summary: string;
+    count: number | null;
+    size: number;
+}>;
+export type ArtifactIndexEntry = z.infer<typeof ArtifactIndexEntrySchema>;
+/**
+ * The artifacts index: a map from artifact name to its index entry. Partial -
+ * a ticket only indexes the artifacts that were actually captured.
+ */
+export declare const ArtifactIndexSchema: z.ZodRecord<z.ZodEnum<["console", "network", "clientState", "storage", "dom", "trace", "screenshot"]>, z.ZodObject<{
+    /** Fetch handle: `GET /tickets/:id/artifacts/:name`. */
+    ref: z.ZodString;
+    /** One-line human/agent summary so the head is decision-complete. */
+    summary: z.ZodString;
+    /** Record count for collection artifacts; null for singletons. */
+    count: z.ZodNullable<z.ZodNumber>;
+    /** Serialized payload size in bytes. */
+    size: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    ref: string;
+    summary: string;
+    count: number | null;
+    size: number;
+}, {
+    ref: string;
+    summary: string;
+    count: number | null;
+    size: number;
+}>>;
+export type ArtifactIndex = Partial<Record<ArtifactName, ArtifactIndexEntry>>;
+/**
+ * TIER 1. The ticket head - always loaded into agent context. Small and
+ * self-sufficient: message, where it happened, the thread, and the index of
+ * heavy artifacts behind refs.
+ */
+export declare const TicketHeadSchema: z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodEnum<["open", "reproducing", "needs_info", "reviewing", "closed", "rejected"]>;
+    createdAt: z.ZodString;
+    /** Who filed it (user id / handle). */
+    reporter: z.ZodString;
+    report: z.ZodObject<{
+        /** Free-text description from the reporter. Capped so a single report can't be
+         * an unbounded blob (intake has no other size gate on this field). */
+        message: z.ZodString;
+        /** Report category (e.g. "bug", "visual", "crash"). Free-form in v0. */
+        kind: z.ZodString;
+        /** App route the report was fired from (e.g. "/cart"). */
+        route: z.ZodString;
+        /** The clicked element, resolved to selector + provenance + component. */
+        target: z.ZodObject<{
+            /** CSS selector identifying the clicked element in the live DOM. */
+            selector: z.ZodNullable<z.ZodString>;
+            /** Build-time source provenance of the element ("file:line:col"). */
+            src: z.ZodNullable<z.ZodString>;
+            /** Display name of the React component that owns the element. */
+            component: z.ZodNullable<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            selector: string | null;
+            src: string | null;
+            component: string | null;
+        }, {
+            selector: string | null;
+            src: string | null;
+            component: string | null;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        kind: string;
+        route: string;
+        target: {
+            selector: string | null;
+            src: string | null;
+            component: string | null;
+        };
+    }, {
+        message: string;
+        kind: string;
+        route: string;
+        target: {
+            selector: string | null;
+            src: string | null;
+            component: string | null;
+        };
+    }>;
+    thread: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        /** Author handle: reporter id, "agent", reviewer id, etc. */
+        by: z.ZodString;
+        text: z.ZodString;
+        at: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        at: string;
+        id: string;
+        by: string;
+        text: string;
+    }, {
+        at: string;
+        id: string;
+        by: string;
+        text: string;
+    }>, "many">;
+    artifacts: z.ZodRecord<z.ZodEnum<["console", "network", "clientState", "storage", "dom", "trace", "screenshot"]>, z.ZodObject<{
+        /** Fetch handle: `GET /tickets/:id/artifacts/:name`. */
+        ref: z.ZodString;
+        /** One-line human/agent summary so the head is decision-complete. */
+        summary: z.ZodString;
+        /** Record count for collection artifacts; null for singletons. */
+        count: z.ZodNullable<z.ZodNumber>;
+        /** Serialized payload size in bytes. */
+        size: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        ref: string;
+        summary: string;
+        count: number | null;
+        size: number;
+    }, {
+        ref: string;
+        summary: string;
+        count: number | null;
+        size: number;
+    }>>;
+    /**
+     * Which project/tenant this ticket belongs to (the SaaS seam). Persisted from
+     * the `projectKey` the widget sent on the {@link ReportBundle}. Null in the
+     * current single-tenant deployment; making multi-tenancy real is a later flip of
+     * this value, not a schema rewrite.
+     */
+    projectKey: z.ZodNullable<z.ZodString>;
+    /**
+     * The git branch the fix lives on (e.g. "ticket/{id}"). Branch-isolated review:
+     * each ticket is fixed in its own worktree + branch off main, so main stays
+     * pristine until Accept. Null until the agent has cut the branch.
+     */
+    branch: z.ZodNullable<z.ZodString>;
+    /**
+     * The isolated preview URL where ONLY this ticket's fix is viewable
+     * (e.g. "http://localhost:8788"), distinct from the pristine main app. "View
+     * fix" links here, not to the live app. Null until the isolated preview is up.
+     */
+    previewUrl: z.ZodNullable<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    status: "open" | "reproducing" | "needs_info" | "reviewing" | "closed" | "rejected";
+    id: string;
+    createdAt: string;
+    reporter: string;
+    report: {
+        message: string;
+        kind: string;
+        route: string;
+        target: {
+            selector: string | null;
+            src: string | null;
+            component: string | null;
+        };
+    };
+    thread: {
+        at: string;
+        id: string;
+        by: string;
+        text: string;
+    }[];
+    artifacts: Partial<Record<"console" | "network" | "clientState" | "storage" | "dom" | "trace" | "screenshot", {
+        ref: string;
+        summary: string;
+        count: number | null;
+        size: number;
+    }>>;
+    projectKey: string | null;
+    branch: string | null;
+    previewUrl: string | null;
+}, {
+    status: "open" | "reproducing" | "needs_info" | "reviewing" | "closed" | "rejected";
+    id: string;
+    createdAt: string;
+    reporter: string;
+    report: {
+        message: string;
+        kind: string;
+        route: string;
+        target: {
+            selector: string | null;
+            src: string | null;
+            component: string | null;
+        };
+    };
+    thread: {
+        at: string;
+        id: string;
+        by: string;
+        text: string;
+    }[];
+    artifacts: Partial<Record<"console" | "network" | "clientState" | "storage" | "dom" | "trace" | "screenshot", {
+        ref: string;
+        summary: string;
+        count: number | null;
+        size: number;
+    }>>;
+    projectKey: string | null;
+    branch: string | null;
+    previewUrl: string | null;
+}>;
+export type TicketHead = z.infer<typeof TicketHeadSchema>;
+/** One captured console line from the ring buffer. */
+export declare const ConsoleEntrySchema: z.ZodObject<{
+    level: z.ZodEnum<["log", "info", "warn", "error", "debug"]>;
+    /** Already-formatted message text. */
+    message: z.ZodString;
+    /** Structured args as captured (best-effort serialized). */
+    args: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+    at: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    at: string;
+    level: "log" | "info" | "warn" | "error" | "debug";
+    args?: unknown[] | undefined;
+}, {
+    message: string;
+    at: string;
+    level: "log" | "info" | "warn" | "error" | "debug";
+    args?: unknown[] | undefined;
+}>;
+export type ConsoleEntry = z.infer<typeof ConsoleEntrySchema>;
+/** Payload for the `console` artifact: the console ring buffer, oldest first.
+ * Length-capped so a forged bundle can't ship an unbounded array. */
+export declare const ConsoleArtifactSchema: z.ZodArray<z.ZodObject<{
+    level: z.ZodEnum<["log", "info", "warn", "error", "debug"]>;
+    /** Already-formatted message text. */
+    message: z.ZodString;
+    /** Structured args as captured (best-effort serialized). */
+    args: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+    at: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    at: string;
+    level: "log" | "info" | "warn" | "error" | "debug";
+    args?: unknown[] | undefined;
+}, {
+    message: string;
+    at: string;
+    level: "log" | "info" | "warn" | "error" | "debug";
+    args?: unknown[] | undefined;
+}>, "many">;
+export type ConsoleArtifact = z.infer<typeof ConsoleArtifactSchema>;
+/**
+ * One captured frontend network call. `traceId` is the spine: it matches the
+ * `traceId` on the {@link TraceRequest} the call hit on the backend.
+ */
+export declare const NetworkEntrySchema: z.ZodObject<{
+    /** Spine id linking this call to its backend request. */
+    traceId: z.ZodString;
+    method: z.ZodString;
+    url: z.ZodString;
+    /** HTTP status; null if the request never completed. */
+    status: z.ZodNullable<z.ZodNumber>;
+    /** Request body as captured (serialized; null if none). */
+    reqBody: z.ZodNullable<z.ZodUnknown>;
+    /** Response body as captured (serialized; null if none). */
+    resBody: z.ZodNullable<z.ZodUnknown>;
+    startedAt: z.ZodString;
+    /** Round-trip duration in milliseconds; null if unknown. */
+    durationMs: z.ZodNullable<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    status: number | null;
+    traceId: string;
+    method: string;
+    url: string;
+    startedAt: string;
+    durationMs: number | null;
+    reqBody?: unknown;
+    resBody?: unknown;
+}, {
+    status: number | null;
+    traceId: string;
+    method: string;
+    url: string;
+    startedAt: string;
+    durationMs: number | null;
+    reqBody?: unknown;
+    resBody?: unknown;
+}>;
+export type NetworkEntry = z.infer<typeof NetworkEntrySchema>;
+/** Payload for the `network` artifact: last N network calls, oldest first.
+ * Length-capped so a forged bundle can't ship an unbounded array. */
+export declare const NetworkArtifactSchema: z.ZodArray<z.ZodObject<{
+    /** Spine id linking this call to its backend request. */
+    traceId: z.ZodString;
+    method: z.ZodString;
+    url: z.ZodString;
+    /** HTTP status; null if the request never completed. */
+    status: z.ZodNullable<z.ZodNumber>;
+    /** Request body as captured (serialized; null if none). */
+    reqBody: z.ZodNullable<z.ZodUnknown>;
+    /** Response body as captured (serialized; null if none). */
+    resBody: z.ZodNullable<z.ZodUnknown>;
+    startedAt: z.ZodString;
+    /** Round-trip duration in milliseconds; null if unknown. */
+    durationMs: z.ZodNullable<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    status: number | null;
+    traceId: string;
+    method: string;
+    url: string;
+    startedAt: string;
+    durationMs: number | null;
+    reqBody?: unknown;
+    resBody?: unknown;
+}, {
+    status: number | null;
+    traceId: string;
+    method: string;
+    url: string;
+    startedAt: string;
+    durationMs: number | null;
+    reqBody?: unknown;
+    resBody?: unknown;
+}>, "many">;
+export type NetworkArtifact = z.infer<typeof NetworkArtifactSchema>;
+/**
+ * Payload for the `clientState` artifact: a snapshot of the mandated state store
+ * at report time. Shape is app-defined, so it's an opaque record.
+ */
+export declare const ClientStateArtifactSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+export type ClientStateArtifact = z.infer<typeof ClientStateArtifactSchema>;
+/**
+ * Payload for the `storage` artifact: localStorage / sessionStorage / cookies
+ * captured at report time. Each is a flat string->string map.
+ */
+export declare const StorageArtifactSchema: z.ZodObject<{
+    local: z.ZodRecord<z.ZodString, z.ZodString>;
+    session: z.ZodRecord<z.ZodString, z.ZodString>;
+    cookies: z.ZodRecord<z.ZodString, z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    local: Record<string, string>;
+    session: Record<string, string>;
+    cookies: Record<string, string>;
+}, {
+    local: Record<string, string>;
+    session: Record<string, string>;
+    cookies: Record<string, string>;
+}>;
+export type StorageArtifact = z.infer<typeof StorageArtifactSchema>;
+/**
+ * Payload for the `dom` artifact: a snapshot of the DOM at report time. `html` is
+ * the serialized document/subtree; `targetSelector` points back at the clicked
+ * element within it.
+ */
+export declare const DomArtifactSchema: z.ZodObject<{
+    /** Serialized DOM (full document or relevant subtree). Capped (~8MB) so a
+     * crafted bundle can't bloat a D1 row / OOM the worker on intake. */
+    html: z.ZodString;
+    /** Selector of the reported element within `html`. */
+    targetSelector: z.ZodNullable<z.ZodString>;
+    /** Viewport size at capture time. */
+    viewport: z.ZodObject<{
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        width: number;
+        height: number;
+    }, {
+        width: number;
+        height: number;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    html: string;
+    targetSelector: string | null;
+    viewport: {
+        width: number;
+        height: number;
+    };
+}, {
+    html: string;
+    targetSelector: string | null;
+    viewport: {
+        width: number;
+        height: number;
+    };
+}>;
+export type DomArtifact = z.infer<typeof DomArtifactSchema>;
+/** One database query recorded inside a backend request. */
+export declare const TraceQuerySchema: z.ZodObject<{
+    /** SQL or query string as executed. */
+    sql: z.ZodString;
+    /** Bound parameters, serialized. */
+    params: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+    /** Execution time in milliseconds. */
+    durationMs: z.ZodNullable<z.ZodNumber>;
+    /** Provenance of the call site issuing the query ("file:line:col"). */
+    src: z.ZodNullable<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    src: string | null;
+    durationMs: number | null;
+    sql: string;
+    params?: unknown[] | undefined;
+}, {
+    src: string | null;
+    durationMs: number | null;
+    sql: string;
+    params?: unknown[] | undefined;
+}>;
+export type TraceQuery = z.infer<typeof TraceQuerySchema>;
+/**
+ * One backend request captured by the `withCapture()` handler wrapper. Joined to
+ * a frontend {@link NetworkEntry} by `traceId`.
+ */
+export declare const TraceRequestSchema: z.ZodObject<{
+    /** Spine id - matches the frontend NetworkEntry that triggered this request. */
+    traceId: z.ZodString;
+    /** Name/identity of the handler that ran. */
+    handler: z.ZodString;
+    /** Provenance of the handler ("file:line:col"). */
+    src: z.ZodNullable<z.ZodString>;
+    method: z.ZodString;
+    url: z.ZodString;
+    status: z.ZodNullable<z.ZodNumber>;
+    /** Queries issued during this request, in order. */
+    queries: z.ZodArray<z.ZodObject<{
+        /** SQL or query string as executed. */
+        sql: z.ZodString;
+        /** Bound parameters, serialized. */
+        params: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+        /** Execution time in milliseconds. */
+        durationMs: z.ZodNullable<z.ZodNumber>;
+        /** Provenance of the call site issuing the query ("file:line:col"). */
+        src: z.ZodNullable<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        src: string | null;
+        durationMs: number | null;
+        sql: string;
+        params?: unknown[] | undefined;
+    }, {
+        src: string | null;
+        durationMs: number | null;
+        sql: string;
+        params?: unknown[] | undefined;
+    }>, "many">;
+    /** Serialized error if the handler threw; null on success. */
+    threw: z.ZodNullable<z.ZodUnknown>;
+    durationMs: z.ZodNullable<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    src: string | null;
+    status: number | null;
+    traceId: string;
+    method: string;
+    url: string;
+    durationMs: number | null;
+    handler: string;
+    queries: {
+        src: string | null;
+        durationMs: number | null;
+        sql: string;
+        params?: unknown[] | undefined;
+    }[];
+    threw?: unknown;
+}, {
+    src: string | null;
+    status: number | null;
+    traceId: string;
+    method: string;
+    url: string;
+    durationMs: number | null;
+    handler: string;
+    queries: {
+        src: string | null;
+        durationMs: number | null;
+        sql: string;
+        params?: unknown[] | undefined;
+    }[];
+    threw?: unknown;
+}>;
+export type TraceRequest = z.infer<typeof TraceRequestSchema>;
+/**
+ * Payload for the `trace` artifact: the backend side of the report. One capture
+ * session containing every backend request that ran during the reported
+ * interaction, each stitched to its frontend call by `traceId`.
+ */
+export declare const TraceArtifactSchema: z.ZodObject<{
+    /** Backend capture session id for the reported interaction. */
+    sessionId: z.ZodString;
+    requests: z.ZodArray<z.ZodObject<{
+        /** Spine id - matches the frontend NetworkEntry that triggered this request. */
+        traceId: z.ZodString;
+        /** Name/identity of the handler that ran. */
+        handler: z.ZodString;
+        /** Provenance of the handler ("file:line:col"). */
+        src: z.ZodNullable<z.ZodString>;
+        method: z.ZodString;
+        url: z.ZodString;
+        status: z.ZodNullable<z.ZodNumber>;
+        /** Queries issued during this request, in order. */
+        queries: z.ZodArray<z.ZodObject<{
+            /** SQL or query string as executed. */
+            sql: z.ZodString;
+            /** Bound parameters, serialized. */
+            params: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+            /** Execution time in milliseconds. */
+            durationMs: z.ZodNullable<z.ZodNumber>;
+            /** Provenance of the call site issuing the query ("file:line:col"). */
+            src: z.ZodNullable<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            src: string | null;
+            durationMs: number | null;
+            sql: string;
+            params?: unknown[] | undefined;
+        }, {
+            src: string | null;
+            durationMs: number | null;
+            sql: string;
+            params?: unknown[] | undefined;
+        }>, "many">;
+        /** Serialized error if the handler threw; null on success. */
+        threw: z.ZodNullable<z.ZodUnknown>;
+        durationMs: z.ZodNullable<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        src: string | null;
+        status: number | null;
+        traceId: string;
+        method: string;
+        url: string;
+        durationMs: number | null;
+        handler: string;
+        queries: {
+            src: string | null;
+            durationMs: number | null;
+            sql: string;
+            params?: unknown[] | undefined;
+        }[];
+        threw?: unknown;
+    }, {
+        src: string | null;
+        status: number | null;
+        traceId: string;
+        method: string;
+        url: string;
+        durationMs: number | null;
+        handler: string;
+        queries: {
+            src: string | null;
+            durationMs: number | null;
+            sql: string;
+            params?: unknown[] | undefined;
+        }[];
+        threw?: unknown;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    sessionId: string;
+    requests: {
+        src: string | null;
+        status: number | null;
+        traceId: string;
+        method: string;
+        url: string;
+        durationMs: number | null;
+        handler: string;
+        queries: {
+            src: string | null;
+            durationMs: number | null;
+            sql: string;
+            params?: unknown[] | undefined;
+        }[];
+        threw?: unknown;
+    }[];
+}, {
+    sessionId: string;
+    requests: {
+        src: string | null;
+        status: number | null;
+        traceId: string;
+        method: string;
+        url: string;
+        durationMs: number | null;
+        handler: string;
+        queries: {
+            src: string | null;
+            durationMs: number | null;
+            sql: string;
+            params?: unknown[] | undefined;
+        }[];
+        threw?: unknown;
+    }[];
+}>;
+export type TraceArtifact = z.infer<typeof TraceArtifactSchema>;
+/**
+ * Payload for the `screenshot` artifact: an actual rendered image of the page at
+ * report time, so the agent (which can see images) and the human reviewer can
+ * directly judge "this looks off" / visual reports that a DOM/CSS snapshot can't
+ * convey. The widget's own report UI is excluded from the shot.
+ *
+ * Kept small on purpose: the longest side is capped (~1280px) and the image is
+ * JPEG-compressed, so the base64 `dataUrl` typically lands well under ~1MB. `png`
+ * is allowed as a fallback but is larger; prefer `jpeg`.
+ */
+export declare const ScreenshotArtifactSchema: z.ZodObject<{
+    /** A `data:` URL holding the base64-encoded image (e.g. `data:image/jpeg;base64,...`).
+     * Scheme-locked to an inline image (a remote http(s) src would turn opening
+     * the artifact into an outbound request to an attacker host) and size-capped
+     * (~12MB) so it can't be used as a DoS payload. */
+    dataUrl: z.ZodString;
+    /** Pixel width of the rendered image. */
+    width: z.ZodNumber;
+    /** Pixel height of the rendered image. */
+    height: z.ZodNumber;
+    /** Encoding of the image embedded in `dataUrl`. */
+    format: z.ZodEnum<["jpeg", "png"]>;
+}, "strip", z.ZodTypeAny, {
+    width: number;
+    height: number;
+    dataUrl: string;
+    format: "jpeg" | "png";
+}, {
+    width: number;
+    height: number;
+    dataUrl: string;
+    format: "jpeg" | "png";
+}>;
+export type ScreenshotArtifact = z.infer<typeof ScreenshotArtifactSchema>;
+/**
+ * Maps each artifact name to the zod schema for its payload. Use this to validate
+ * a payload before persisting it or after fetching it by ref:
+ *
+ *   ArtifactPayloadSchemas[name].parse(payload)
+ */
+export declare const ArtifactPayloadSchemas: {
+    readonly console: z.ZodArray<z.ZodObject<{
+        level: z.ZodEnum<["log", "info", "warn", "error", "debug"]>;
+        /** Already-formatted message text. */
+        message: z.ZodString;
+        /** Structured args as captured (best-effort serialized). */
+        args: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+        at: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        at: string;
+        level: "log" | "info" | "warn" | "error" | "debug";
+        args?: unknown[] | undefined;
+    }, {
+        message: string;
+        at: string;
+        level: "log" | "info" | "warn" | "error" | "debug";
+        args?: unknown[] | undefined;
+    }>, "many">;
+    readonly network: z.ZodArray<z.ZodObject<{
+        /** Spine id linking this call to its backend request. */
+        traceId: z.ZodString;
+        method: z.ZodString;
+        url: z.ZodString;
+        /** HTTP status; null if the request never completed. */
+        status: z.ZodNullable<z.ZodNumber>;
+        /** Request body as captured (serialized; null if none). */
+        reqBody: z.ZodNullable<z.ZodUnknown>;
+        /** Response body as captured (serialized; null if none). */
+        resBody: z.ZodNullable<z.ZodUnknown>;
+        startedAt: z.ZodString;
+        /** Round-trip duration in milliseconds; null if unknown. */
+        durationMs: z.ZodNullable<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        status: number | null;
+        traceId: string;
+        method: string;
+        url: string;
+        startedAt: string;
+        durationMs: number | null;
+        reqBody?: unknown;
+        resBody?: unknown;
+    }, {
+        status: number | null;
+        traceId: string;
+        method: string;
+        url: string;
+        startedAt: string;
+        durationMs: number | null;
+        reqBody?: unknown;
+        resBody?: unknown;
+    }>, "many">;
+    readonly clientState: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    readonly storage: z.ZodObject<{
+        local: z.ZodRecord<z.ZodString, z.ZodString>;
+        session: z.ZodRecord<z.ZodString, z.ZodString>;
+        cookies: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        local: Record<string, string>;
+        session: Record<string, string>;
+        cookies: Record<string, string>;
+    }, {
+        local: Record<string, string>;
+        session: Record<string, string>;
+        cookies: Record<string, string>;
+    }>;
+    readonly dom: z.ZodObject<{
+        /** Serialized DOM (full document or relevant subtree). Capped (~8MB) so a
+         * crafted bundle can't bloat a D1 row / OOM the worker on intake. */
+        html: z.ZodString;
+        /** Selector of the reported element within `html`. */
+        targetSelector: z.ZodNullable<z.ZodString>;
+        /** Viewport size at capture time. */
+        viewport: z.ZodObject<{
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            width: number;
+            height: number;
+        }, {
+            width: number;
+            height: number;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        html: string;
+        targetSelector: string | null;
+        viewport: {
+            width: number;
+            height: number;
+        };
+    }, {
+        html: string;
+        targetSelector: string | null;
+        viewport: {
+            width: number;
+            height: number;
+        };
+    }>;
+    readonly trace: z.ZodObject<{
+        /** Backend capture session id for the reported interaction. */
+        sessionId: z.ZodString;
+        requests: z.ZodArray<z.ZodObject<{
+            /** Spine id - matches the frontend NetworkEntry that triggered this request. */
+            traceId: z.ZodString;
+            /** Name/identity of the handler that ran. */
+            handler: z.ZodString;
+            /** Provenance of the handler ("file:line:col"). */
+            src: z.ZodNullable<z.ZodString>;
+            method: z.ZodString;
+            url: z.ZodString;
+            status: z.ZodNullable<z.ZodNumber>;
+            /** Queries issued during this request, in order. */
+            queries: z.ZodArray<z.ZodObject<{
+                /** SQL or query string as executed. */
+                sql: z.ZodString;
+                /** Bound parameters, serialized. */
+                params: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+                /** Execution time in milliseconds. */
+                durationMs: z.ZodNullable<z.ZodNumber>;
+                /** Provenance of the call site issuing the query ("file:line:col"). */
+                src: z.ZodNullable<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                src: string | null;
+                durationMs: number | null;
+                sql: string;
+                params?: unknown[] | undefined;
+            }, {
+                src: string | null;
+                durationMs: number | null;
+                sql: string;
+                params?: unknown[] | undefined;
+            }>, "many">;
+            /** Serialized error if the handler threw; null on success. */
+            threw: z.ZodNullable<z.ZodUnknown>;
+            durationMs: z.ZodNullable<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            src: string | null;
+            status: number | null;
+            traceId: string;
+            method: string;
+            url: string;
+            durationMs: number | null;
+            handler: string;
+            queries: {
+                src: string | null;
+                durationMs: number | null;
+                sql: string;
+                params?: unknown[] | undefined;
+            }[];
+            threw?: unknown;
+        }, {
+            src: string | null;
+            status: number | null;
+            traceId: string;
+            method: string;
+            url: string;
+            durationMs: number | null;
+            handler: string;
+            queries: {
+                src: string | null;
+                durationMs: number | null;
+                sql: string;
+                params?: unknown[] | undefined;
+            }[];
+            threw?: unknown;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        sessionId: string;
+        requests: {
+            src: string | null;
+            status: number | null;
+            traceId: string;
+            method: string;
+            url: string;
+            durationMs: number | null;
+            handler: string;
+            queries: {
+                src: string | null;
+                durationMs: number | null;
+                sql: string;
+                params?: unknown[] | undefined;
+            }[];
+            threw?: unknown;
+        }[];
+    }, {
+        sessionId: string;
+        requests: {
+            src: string | null;
+            status: number | null;
+            traceId: string;
+            method: string;
+            url: string;
+            durationMs: number | null;
+            handler: string;
+            queries: {
+                src: string | null;
+                durationMs: number | null;
+                sql: string;
+                params?: unknown[] | undefined;
+            }[];
+            threw?: unknown;
+        }[];
+    }>;
+    readonly screenshot: z.ZodObject<{
+        /** A `data:` URL holding the base64-encoded image (e.g. `data:image/jpeg;base64,...`).
+         * Scheme-locked to an inline image (a remote http(s) src would turn opening
+         * the artifact into an outbound request to an attacker host) and size-capped
+         * (~12MB) so it can't be used as a DoS payload. */
+        dataUrl: z.ZodString;
+        /** Pixel width of the rendered image. */
+        width: z.ZodNumber;
+        /** Pixel height of the rendered image. */
+        height: z.ZodNumber;
+        /** Encoding of the image embedded in `dataUrl`. */
+        format: z.ZodEnum<["jpeg", "png"]>;
+    }, "strip", z.ZodTypeAny, {
+        width: number;
+        height: number;
+        dataUrl: string;
+        format: "jpeg" | "png";
+    }, {
+        width: number;
+        height: number;
+        dataUrl: string;
+        format: "jpeg" | "png";
+    }>;
+};
+/** Type-level map from artifact name to its decoded payload type. */
+export interface ArtifactPayloadMap {
+    console: ConsoleArtifact;
+    network: NetworkArtifact;
+    clientState: ClientStateArtifact;
+    storage: StorageArtifact;
+    dom: DomArtifact;
+    trace: TraceArtifact;
+    screenshot: ScreenshotArtifact;
+}
+/** Union of all artifact payloads (the body served behind any ref). */
+export type ArtifactPayload = ArtifactPayloadMap[ArtifactName];
+/**
+ * What the `<ReportButton>` produces and POSTs to create a ticket: the head's
+ * report core plus every captured artifact payload inline. The server splits this
+ * into the persisted head (with a built index) and the artifact rows.
+ */
+export declare const ReportBundleSchema: z.ZodObject<{
+    reporter: z.ZodString;
+    /**
+     * Which project/tenant this report belongs to (the SaaS seam). The widget is
+     * configured with a `projectKey` and stamps it here; the server persists it onto
+     * the {@link TicketHead}. Null when the widget is unkeyed (single-tenant); making
+     * multi-tenancy real is a later flip, not a schema rewrite.
+     */
+    projectKey: z.ZodNullable<z.ZodString>;
+    report: z.ZodObject<{
+        /** Free-text description from the reporter. Capped so a single report can't be
+         * an unbounded blob (intake has no other size gate on this field). */
+        message: z.ZodString;
+        /** Report category (e.g. "bug", "visual", "crash"). Free-form in v0. */
+        kind: z.ZodString;
+        /** App route the report was fired from (e.g. "/cart"). */
+        route: z.ZodString;
+        /** The clicked element, resolved to selector + provenance + component. */
+        target: z.ZodObject<{
+            /** CSS selector identifying the clicked element in the live DOM. */
+            selector: z.ZodNullable<z.ZodString>;
+            /** Build-time source provenance of the element ("file:line:col"). */
+            src: z.ZodNullable<z.ZodString>;
+            /** Display name of the React component that owns the element. */
+            component: z.ZodNullable<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            selector: string | null;
+            src: string | null;
+            component: string | null;
+        }, {
+            selector: string | null;
+            src: string | null;
+            component: string | null;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        kind: string;
+        route: string;
+        target: {
+            selector: string | null;
+            src: string | null;
+            component: string | null;
+        };
+    }, {
+        message: string;
+        kind: string;
+        route: string;
+        target: {
+            selector: string | null;
+            src: string | null;
+            component: string | null;
+        };
+    }>;
+    artifacts: z.ZodObject<{
+        console: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodObject<{
+            level: z.ZodEnum<["log", "info", "warn", "error", "debug"]>;
+            /** Already-formatted message text. */
+            message: z.ZodString;
+            /** Structured args as captured (best-effort serialized). */
+            args: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+            at: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            message: string;
+            at: string;
+            level: "log" | "info" | "warn" | "error" | "debug";
+            args?: unknown[] | undefined;
+        }, {
+            message: string;
+            at: string;
+            level: "log" | "info" | "warn" | "error" | "debug";
+            args?: unknown[] | undefined;
+        }>, "many">>>;
+        network: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodObject<{
+            /** Spine id linking this call to its backend request. */
+            traceId: z.ZodString;
+            method: z.ZodString;
+            url: z.ZodString;
+            /** HTTP status; null if the request never completed. */
+            status: z.ZodNullable<z.ZodNumber>;
+            /** Request body as captured (serialized; null if none). */
+            reqBody: z.ZodNullable<z.ZodUnknown>;
+            /** Response body as captured (serialized; null if none). */
+            resBody: z.ZodNullable<z.ZodUnknown>;
+            startedAt: z.ZodString;
+            /** Round-trip duration in milliseconds; null if unknown. */
+            durationMs: z.ZodNullable<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            status: number | null;
+            traceId: string;
+            method: string;
+            url: string;
+            startedAt: string;
+            durationMs: number | null;
+            reqBody?: unknown;
+            resBody?: unknown;
+        }, {
+            status: number | null;
+            traceId: string;
+            method: string;
+            url: string;
+            startedAt: string;
+            durationMs: number | null;
+            reqBody?: unknown;
+            resBody?: unknown;
+        }>, "many">>>;
+        clientState: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        storage: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+            local: z.ZodRecord<z.ZodString, z.ZodString>;
+            session: z.ZodRecord<z.ZodString, z.ZodString>;
+            cookies: z.ZodRecord<z.ZodString, z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            local: Record<string, string>;
+            session: Record<string, string>;
+            cookies: Record<string, string>;
+        }, {
+            local: Record<string, string>;
+            session: Record<string, string>;
+            cookies: Record<string, string>;
+        }>>>;
+        dom: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+            /** Serialized DOM (full document or relevant subtree). Capped (~8MB) so a
+             * crafted bundle can't bloat a D1 row / OOM the worker on intake. */
+            html: z.ZodString;
+            /** Selector of the reported element within `html`. */
+            targetSelector: z.ZodNullable<z.ZodString>;
+            /** Viewport size at capture time. */
+            viewport: z.ZodObject<{
+                width: z.ZodNumber;
+                height: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                width: number;
+                height: number;
+            }, {
+                width: number;
+                height: number;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            html: string;
+            targetSelector: string | null;
+            viewport: {
+                width: number;
+                height: number;
+            };
+        }, {
+            html: string;
+            targetSelector: string | null;
+            viewport: {
+                width: number;
+                height: number;
+            };
+        }>>>;
+        trace: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+            /** Backend capture session id for the reported interaction. */
+            sessionId: z.ZodString;
+            requests: z.ZodArray<z.ZodObject<{
+                /** Spine id - matches the frontend NetworkEntry that triggered this request. */
+                traceId: z.ZodString;
+                /** Name/identity of the handler that ran. */
+                handler: z.ZodString;
+                /** Provenance of the handler ("file:line:col"). */
+                src: z.ZodNullable<z.ZodString>;
+                method: z.ZodString;
+                url: z.ZodString;
+                status: z.ZodNullable<z.ZodNumber>;
+                /** Queries issued during this request, in order. */
+                queries: z.ZodArray<z.ZodObject<{
+                    /** SQL or query string as executed. */
+                    sql: z.ZodString;
+                    /** Bound parameters, serialized. */
+                    params: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+                    /** Execution time in milliseconds. */
+                    durationMs: z.ZodNullable<z.ZodNumber>;
+                    /** Provenance of the call site issuing the query ("file:line:col"). */
+                    src: z.ZodNullable<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    src: string | null;
+                    durationMs: number | null;
+                    sql: string;
+                    params?: unknown[] | undefined;
+                }, {
+                    src: string | null;
+                    durationMs: number | null;
+                    sql: string;
+                    params?: unknown[] | undefined;
+                }>, "many">;
+                /** Serialized error if the handler threw; null on success. */
+                threw: z.ZodNullable<z.ZodUnknown>;
+                durationMs: z.ZodNullable<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                src: string | null;
+                status: number | null;
+                traceId: string;
+                method: string;
+                url: string;
+                durationMs: number | null;
+                handler: string;
+                queries: {
+                    src: string | null;
+                    durationMs: number | null;
+                    sql: string;
+                    params?: unknown[] | undefined;
+                }[];
+                threw?: unknown;
+            }, {
+                src: string | null;
+                status: number | null;
+                traceId: string;
+                method: string;
+                url: string;
+                durationMs: number | null;
+                handler: string;
+                queries: {
+                    src: string | null;
+                    durationMs: number | null;
+                    sql: string;
+                    params?: unknown[] | undefined;
+                }[];
+                threw?: unknown;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            sessionId: string;
+            requests: {
+                src: string | null;
+                status: number | null;
+                traceId: string;
+                method: string;
+                url: string;
+                durationMs: number | null;
+                handler: string;
+                queries: {
+                    src: string | null;
+                    durationMs: number | null;
+                    sql: string;
+                    params?: unknown[] | undefined;
+                }[];
+                threw?: unknown;
+            }[];
+        }, {
+            sessionId: string;
+            requests: {
+                src: string | null;
+                status: number | null;
+                traceId: string;
+                method: string;
+                url: string;
+                durationMs: number | null;
+                handler: string;
+                queries: {
+                    src: string | null;
+                    durationMs: number | null;
+                    sql: string;
+                    params?: unknown[] | undefined;
+                }[];
+                threw?: unknown;
+            }[];
+        }>>>;
+        screenshot: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+            /** A `data:` URL holding the base64-encoded image (e.g. `data:image/jpeg;base64,...`).
+             * Scheme-locked to an inline image (a remote http(s) src would turn opening
+             * the artifact into an outbound request to an attacker host) and size-capped
+             * (~12MB) so it can't be used as a DoS payload. */
+            dataUrl: z.ZodString;
+            /** Pixel width of the rendered image. */
+            width: z.ZodNumber;
+            /** Pixel height of the rendered image. */
+            height: z.ZodNumber;
+            /** Encoding of the image embedded in `dataUrl`. */
+            format: z.ZodEnum<["jpeg", "png"]>;
+        }, "strip", z.ZodTypeAny, {
+            width: number;
+            height: number;
+            dataUrl: string;
+            format: "jpeg" | "png";
+        }, {
+            width: number;
+            height: number;
+            dataUrl: string;
+            format: "jpeg" | "png";
+        }>>>;
+    }, "strip", z.ZodTypeAny, {
+        console?: {
+            message: string;
+            at: string;
+            level: "log" | "info" | "warn" | "error" | "debug";
+            args?: unknown[] | undefined;
+        }[] | undefined;
+        network?: {
+            status: number | null;
+            traceId: string;
+            method: string;
+            url: string;
+            startedAt: string;
+            durationMs: number | null;
+            reqBody?: unknown;
+            resBody?: unknown;
+        }[] | undefined;
+        clientState?: Record<string, unknown> | undefined;
+        storage?: {
+            local: Record<string, string>;
+            session: Record<string, string>;
+            cookies: Record<string, string>;
+        } | undefined;
+        dom?: {
+            html: string;
+            targetSelector: string | null;
+            viewport: {
+                width: number;
+                height: number;
+            };
+        } | undefined;
+        trace?: {
+            sessionId: string;
+            requests: {
+                src: string | null;
+                status: number | null;
+                traceId: string;
+                method: string;
+                url: string;
+                durationMs: number | null;
+                handler: string;
+                queries: {
+                    src: string | null;
+                    durationMs: number | null;
+                    sql: string;
+                    params?: unknown[] | undefined;
+                }[];
+                threw?: unknown;
+            }[];
+        } | undefined;
+        screenshot?: {
+            width: number;
+            height: number;
+            dataUrl: string;
+            format: "jpeg" | "png";
+        } | undefined;
+    }, {
+        console?: {
+            message: string;
+            at: string;
+            level: "log" | "info" | "warn" | "error" | "debug";
+            args?: unknown[] | undefined;
+        }[] | undefined;
+        network?: {
+            status: number | null;
+            traceId: string;
+            method: string;
+            url: string;
+            startedAt: string;
+            durationMs: number | null;
+            reqBody?: unknown;
+            resBody?: unknown;
+        }[] | undefined;
+        clientState?: Record<string, unknown> | undefined;
+        storage?: {
+            local: Record<string, string>;
+            session: Record<string, string>;
+            cookies: Record<string, string>;
+        } | undefined;
+        dom?: {
+            html: string;
+            targetSelector: string | null;
+            viewport: {
+                width: number;
+                height: number;
+            };
+        } | undefined;
+        trace?: {
+            sessionId: string;
+            requests: {
+                src: string | null;
+                status: number | null;
+                traceId: string;
+                method: string;
+                url: string;
+                durationMs: number | null;
+                handler: string;
+                queries: {
+                    src: string | null;
+                    durationMs: number | null;
+                    sql: string;
+                    params?: unknown[] | undefined;
+                }[];
+                threw?: unknown;
+            }[];
+        } | undefined;
+        screenshot?: {
+            width: number;
+            height: number;
+            dataUrl: string;
+            format: "jpeg" | "png";
+        } | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    reporter: string;
+    report: {
+        message: string;
+        kind: string;
+        route: string;
+        target: {
+            selector: string | null;
+            src: string | null;
+            component: string | null;
+        };
+    };
+    artifacts: {
+        console?: {
+            message: string;
+            at: string;
+            level: "log" | "info" | "warn" | "error" | "debug";
+            args?: unknown[] | undefined;
+        }[] | undefined;
+        network?: {
+            status: number | null;
+            traceId: string;
+            method: string;
+            url: string;
+            startedAt: string;
+            durationMs: number | null;
+            reqBody?: unknown;
+            resBody?: unknown;
+        }[] | undefined;
+        clientState?: Record<string, unknown> | undefined;
+        storage?: {
+            local: Record<string, string>;
+            session: Record<string, string>;
+            cookies: Record<string, string>;
+        } | undefined;
+        dom?: {
+            html: string;
+            targetSelector: string | null;
+            viewport: {
+                width: number;
+                height: number;
+            };
+        } | undefined;
+        trace?: {
+            sessionId: string;
+            requests: {
+                src: string | null;
+                status: number | null;
+                traceId: string;
+                method: string;
+                url: string;
+                durationMs: number | null;
+                handler: string;
+                queries: {
+                    src: string | null;
+                    durationMs: number | null;
+                    sql: string;
+                    params?: unknown[] | undefined;
+                }[];
+                threw?: unknown;
+            }[];
+        } | undefined;
+        screenshot?: {
+            width: number;
+            height: number;
+            dataUrl: string;
+            format: "jpeg" | "png";
+        } | undefined;
+    };
+    projectKey: string | null;
+}, {
+    reporter: string;
+    report: {
+        message: string;
+        kind: string;
+        route: string;
+        target: {
+            selector: string | null;
+            src: string | null;
+            component: string | null;
+        };
+    };
+    artifacts: {
+        console?: {
+            message: string;
+            at: string;
+            level: "log" | "info" | "warn" | "error" | "debug";
+            args?: unknown[] | undefined;
+        }[] | undefined;
+        network?: {
+            status: number | null;
+            traceId: string;
+            method: string;
+            url: string;
+            startedAt: string;
+            durationMs: number | null;
+            reqBody?: unknown;
+            resBody?: unknown;
+        }[] | undefined;
+        clientState?: Record<string, unknown> | undefined;
+        storage?: {
+            local: Record<string, string>;
+            session: Record<string, string>;
+            cookies: Record<string, string>;
+        } | undefined;
+        dom?: {
+            html: string;
+            targetSelector: string | null;
+            viewport: {
+                width: number;
+                height: number;
+            };
+        } | undefined;
+        trace?: {
+            sessionId: string;
+            requests: {
+                src: string | null;
+                status: number | null;
+                traceId: string;
+                method: string;
+                url: string;
+                durationMs: number | null;
+                handler: string;
+                queries: {
+                    src: string | null;
+                    durationMs: number | null;
+                    sql: string;
+                    params?: unknown[] | undefined;
+                }[];
+                threw?: unknown;
+            }[];
+        } | undefined;
+        screenshot?: {
+            width: number;
+            height: number;
+            dataUrl: string;
+            format: "jpeg" | "png";
+        } | undefined;
+    };
+    projectKey: string | null;
+}>;
+export type ReportBundle = z.infer<typeof ReportBundleSchema>;
+//# sourceMappingURL=index.d.ts.map