@crvouga/atlas 1.1.0 → 1.3.0

package/dist/reports/src/evidence-scope.js

@@ -0,0 +1,129 @@
+/** The fields of a scope that say something about the evidence and that `verified` may name, in the order they are shown. */
+export const SCOPE_DIMENSIONS = ['surface', 'deviceKind', 'syntheticData', 'dependencies', 'audioCaptured', 'pacing'];
+/** The filter token of a recording that declares no scope at all. */
+export const UNKNOWN_SCOPE = 'unknown';
+/**
+ * The declaration that applies to something: the nearest one wins as a whole, never field by field, so a recording
+ * never shows a limitation or a device that was declared for another source. Pass the candidates nearest first
+ * (attachment, attempt, check, part, layer); absent ones are skipped. Undefined when none declares a scope.
+ *
+ * @example
+ * ```ts
+ * effectiveScope(attachment.scope, attempt.scope, check.scope, layer.scope);
+ * ```
+ */
+export function effectiveScope(...candidates) {
+    return candidates.find((candidate) => candidate !== undefined);
+}
+const word = (value) => value.normalize('NFC').trim().toLowerCase().replace(/\s+/g, '-');
+/** A stable string that is equal for equal declarations (key order never matters), to tell one scope from another. */
+export function scopeKey(scope) {
+    if (!scope)
+        return UNKNOWN_SCOPE;
+    const sort = (value) => Array.isArray(value) ? value.map(sort) : value && typeof value === 'object' ? Object.fromEntries(Object.entries(value).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)).map(([key, item]) => [key, sort(item)])) : value;
+    return JSON.stringify(sort(scope));
+}
+/**
+ * The filter tokens one declaration states, normalized (letter case and spaces never matter): `surface:<value>`,
+ * `device:<value>`, `data:synthetic` or `data:real`, `dependencies:<value>`, `audio:recorded` or `audio:silent`,
+ * `pacing:<value>`. A field that is not declared adds no token. No scope at all is the single token
+ * {@link UNKNOWN_SCOPE}, so a filter can ask for the unknown on purpose; a scope that declares nothing readable is
+ * also unknown.
+ */
+export function scopeTokens(scope) {
+    const tokens = [];
+    if (scope?.surface)
+        tokens.push(`surface:${word(scope.surface)}`);
+    if (scope?.deviceKind)
+        tokens.push(`device:${word(scope.deviceKind)}`);
+    if (scope?.syntheticData !== undefined)
+        tokens.push(scope.syntheticData ? 'data:synthetic' : 'data:real');
+    if (scope?.dependencies)
+        tokens.push(`dependencies:${word(scope.dependencies)}`);
+    if (scope?.audioCaptured !== undefined)
+        tokens.push(scope.audioCaptured ? 'audio:recorded' : 'audio:silent');
+    if (scope?.pacing)
+        tokens.push(`pacing:${word(scope.pacing)}`);
+    return tokens.length ? tokens : [UNKNOWN_SCOPE];
+}
+/**
+ * Whether one recording's tokens satisfy a filter: every wanted token must be among them. Tokens compare normalized.
+ * An empty filter matches everything. The token {@link UNKNOWN_SCOPE} matches only a recording with no declared
+ * fields, so asking for `device:physical` never includes a recording that did not say what it ran on.
+ */
+export function matchesScope(tokens, wanted) {
+    const have = new Set(tokens.map(word));
+    return wanted.every(token => have.has(word(token)));
+}
+const title = (value) => { const text = value.replace(/[-_]+/g, ' ').trim(); return text.charAt(0).toUpperCase() + text.slice(1); };
+const LABELS = { surface: 'Surface', deviceKind: 'Device', syntheticData: 'Data', dependencies: 'Dependencies', audioCaptured: 'Audio', pacing: 'Pacing' };
+function valueOf(scope, dimension) {
+    switch (dimension) {
+        case 'surface': return scope.surface ? title(scope.surface) : undefined;
+        case 'deviceKind': return scope.deviceKind ? title(scope.deviceKind) : undefined;
+        case 'syntheticData': return scope.syntheticData === undefined ? undefined : scope.syntheticData ? 'Synthetic' : 'Real';
+        case 'dependencies': return scope.dependencies ? title(scope.dependencies) : undefined;
+        case 'audioCaptured': return scope.audioCaptured === undefined ? undefined : scope.audioCaptured ? 'Recorded' : 'Silent';
+        case 'pacing': return scope.pacing ? title(scope.pacing) : undefined;
+    }
+}
+/**
+ * Every dimension of a scope with its value and how it is known, in a fixed order, including the ones nobody declared
+ * (`Not declared`, basis `undeclared`). A dimension is `verified` only when the scope's `verified` names it and it has
+ * a value; everything else a producer wrote is `declared`. With no scope every dimension is undeclared.
+ */
+export function scopeFacts(scope) {
+    const verified = new Set(scope?.verified ?? []);
+    return SCOPE_DIMENSIONS.map(dimension => {
+        const value = scope ? valueOf(scope, dimension) : undefined;
+        return { dimension, label: LABELS[dimension], value: value ?? 'Not declared', basis: value === undefined ? 'undeclared' : verified.has(dimension) ? 'verified' : 'declared' };
+    });
+}
+/**
+ * The concise badges for a scope: one per declared dimension, in a fixed order (`Surface: Browser`, `Device: Simulator`, `Synthetic
+ * data`, `Scripted dependencies`, `Silent`, `Paced`). With no declared dimension the one badge `Scope unknown`, so
+ * a reviewer is told nothing was claimed rather than shown nothing.
+ */
+export function scopeBadges(scope) {
+    const badges = [];
+    for (const fact of scopeFacts(scope)) {
+        if (fact.basis === 'undeclared')
+            continue;
+        const text = fact.dimension === 'surface' || fact.dimension === 'deviceKind' ? `${fact.label}: ${fact.value}`
+            : fact.dimension === 'syntheticData' ? `${fact.value} data`
+                : fact.dimension === 'dependencies' ? `${fact.value} dependencies`
+                    : fact.dimension === 'audioCaptured' ? (fact.value === 'Silent' ? 'Silent' : 'Audio recorded')
+                        : fact.value;
+        badges.push({ dimension: fact.dimension, text, basis: fact.basis });
+    }
+    return badges.length ? badges : [{ dimension: 'unknown', text: 'Scope unknown', basis: 'undeclared' }];
+}
+/**
+ * What a reviewer must not read into evidence: a sentence per thing that is not shown. It names the assertions the
+ * result stands on when there are some (so activity visible beyond them is not verified), and every kind of reality
+ * that was not declared. Empty only for a scope that declares and verifies everything and lists no limitation.
+ */
+export function scopeCaveats(scope) {
+    const out = [];
+    if (!scope || scopeTokens(scope)[0] === UNKNOWN_SCOPE)
+        return ['Scope not declared: do not assume this ran live, on a physical device, with real audio or end to end.'];
+    if (scope.asserted?.length)
+        out.push(`Only these were asserted: ${scope.asserted.join('; ')}. Other activity visible in the recording is not verified.`);
+    else
+        out.push('No assertion boundary was declared: activity visible in the recording is not verified behavior.');
+    if (scope.syntheticData === true)
+        out.push('Uses synthetic data: not a statement about production data.');
+    if (scope.dependencies === undefined)
+        out.push('Whether dependencies were scripted or live is not declared.');
+    else if (word(scope.dependencies) !== 'live')
+        out.push(`Dependencies were ${word(scope.dependencies)}, not live.`);
+    if (scope.audioCaptured === undefined)
+        out.push('Whether audio was captured is not declared.');
+    else if (!scope.audioCaptured)
+        out.push('Silent: nothing audible was recorded.');
+    if (scope.deviceKind === undefined)
+        out.push('The kind of device is not declared.');
+    for (const limit of scope.limitations ?? [])
+        out.push(limit);
+    return out;
+}

package/dist/reports/src/evidence-types.d.ts

@@ -9,7 +9,7 @@
  * @see docs/report-contract.md
  */
 import type { EvidenceMeasurement, EvidenceStatus } from './explorer-types.js';
-import type { LayerRun } from '../../schema/src/layer.js';
+import type { EvidenceScope, LayerRun } from '../../schema/src/layer.js';
 import type { LayerParameters } from './layer-types.js';
 /** Where a recorded test's timeline and captured files are read from. */
 export type RecordingAddress = {
@@ -51,10 +51,14 @@ export type VideoRef = {
     readonly attempt?: number;
     /** The name of the step that holds it, when `owner` is `step`. */
     readonly step?: string;
+    /** The normalized tags of this attachment itself (`demo`), so a query can ask for a tagged video rather than a result that has a video and some tagged file. Absent when it has none (and in documents of older servers). */
+    readonly tags?: readonly string[];
     /** What identifies the bytes (digest, bundle key or address); references with the same one are the same recording. Absent when `available` is false. */
     readonly recording?: string;
     /** False when the reference names no bytes at all (no bundle key, address or inline text), so it can never be played. */
     readonly available: boolean;
+    /** What this recording shows, as declared for it: its own `scope`, else its attempt's, check's, part's or layer's. Absent when none declared one: its scope is unknown, not live, physical or audible. */
+    readonly scope?: EvidenceScope;
 };
 /** Video availability as counts: references, distinct playable recordings (deduplicated), and references that cannot be played. */
 export type VideoCounts = {

package/dist/reports/src/explorer-types.d.ts

@@ -36,7 +36,7 @@ export type EvidenceMeasurement = {
     readonly limit?: number;
 };
 /** What a check may carry beyond its outcome. All optional and open: see docs/extending.md. */
-export type EvidenceExtras = Partial<Pick<import('../../schema/src/layer.js').Check, 'tags' | 'labels' | 'links' | 'steps' | 'attachments' | 'annotations' | 'attempts' | 'extensions'>>;
+export type EvidenceExtras = Partial<Pick<import('../../schema/src/layer.js').Check, 'tags' | 'labels' | 'links' | 'steps' | 'attachments' | 'annotations' | 'attempts' | 'extensions' | 'scope'>>;
 /** One check of a part, as recorded. */
 export type EvidenceCheck = EvidenceExtras & {
     /** Stable across runs; the newer result replaces the older one only if both used the same id. */

package/dist/reports/src/layer-merge.js

@@ -1,4 +1,5 @@
-import { summarizeEvidence, summarizeLayerEvidence } from './evidence-detail.js';
+import { summarizeEvidenceIn, summarizeLayerEvidence } from './evidence-detail.js';
+import { effectiveScope } from './evidence-scope.js';
 import { layerPlace } from './layer-axes.js';
 /**
  * A short, deterministic fingerprint of a spec's text, shaped `<length>:<hash>:<hash>` (the length in UTF-16 code
@@ -79,7 +80,7 @@ export function layerEvidence(summary, backend) {
     for (const part of summary.parts) {
         for (const check of part.checks) {
             const test = tests.get(check.id);
-            const evidence = summarizeEvidence(check);
+            const evidence = summarizeEvidenceIn(effectiveScope(part.scope, summary.scope), check);
             const item = expectations?.get(check.id);
             rows.push({
                 kind: part.kind,

package/dist/reports/src/layer-types.d.ts

@@ -15,7 +15,7 @@ import type { SourceRecord } from './protocol.js';
 /** String choices (such as `{ device: 'iphone-15' }`) that make a result its own slot. Compared as sorted key/value pairs. */
 export type LayerParameters = Readonly<Record<string, string>>;
 /** What a layer may carry as a whole. All optional and open: see docs/extending.md. */
-export type LayerExtras = Partial<Pick<import('../../schema/src/layer.js').LayerDocument, 'tags' | 'labels' | 'links' | 'attachments' | 'annotations' | 'extensions' | 'recordings'>>;
+export type LayerExtras = Partial<Pick<import('../../schema/src/layer.js').LayerDocument, 'tags' | 'labels' | 'links' | 'attachments' | 'annotations' | 'extensions' | 'recordings' | 'scope'>>;
 /** A layer without its captured files: what composition and the viewer's lists read. */
 export type LayerSummary = LayerExtras & {
     /** `modified`: recorded from a checkout with uncommitted changes. `unknown`: origin not captured. Absent for a clean checkout. Advisory; never changes a status. */

package/dist/reports/src/publish-checks.js

@@ -123,6 +123,7 @@ export async function publishChecks(store, input, options = {}) {
         ...(args.links?.length ? { links: args.links } : {}),
         ...(layerEvidence.attachments?.length ? { attachments: layerEvidence.attachments } : {}),
         ...(args.annotations?.length ? { annotations: args.annotations } : {}),
+        ...(args.scope ? { scope: args.scope } : {}),
         ...(args.extensions && Object.keys(args.extensions).length ? { extensions: args.extensions } : {})
     };
     const bundle = entries.size ? await writeBundle(store, (async function* () { for (const entry of [...entries.values()].sort((a, b) => (a.key < b.key ? -1 : 1)))

package/dist/reports/src/reporter.d.ts

@@ -13,7 +13,7 @@ import { type PublishChecksInput } from '../../schema/src/layer.js';
 import type { ObjectStore } from './object-store.js';
 type Check = PublishChecksInput['checks'][number];
 /** What every layer of one stream shares: who is reporting, from where. Whatever `publishChecks` takes, except the checks and the time. */
-export type ReporterIdentity = Pick<PublishChecksInput, 'producer' | 'kind' | 'title' | 'sha' | 'branch' | 'runUrl' | 'run' | 'environment' | 'parameters' | 'freshness' | 'specs' | 'tags' | 'labels' | 'links' | 'attachments' | 'annotations' | 'extensions'>;
+export type ReporterIdentity = Pick<PublishChecksInput, 'producer' | 'kind' | 'title' | 'sha' | 'branch' | 'runUrl' | 'run' | 'environment' | 'parameters' | 'freshness' | 'specs' | 'tags' | 'labels' | 'links' | 'attachments' | 'annotations' | 'scope' | 'extensions'>;
 /** How a reporter sends: the `store` (a folder, S3, or `httpStore` for a server), how often (`flushMs`, `batchSize`), how hard it tries (`attempts`, `backoffMs`), what it tells (`onError`, `onPublished`), and the clock and sleep for tests. */
 export type ReporterOptions = {
     /** Where layers go: a directory, S3, or `httpStore` for an Atlas server. */

package/dist/reports/src/reports-explorer-route.d.ts

@@ -67,6 +67,29 @@ export declare function createReportsExplorerApp(deps: ReportsExplorerDeps): imp
                 } | null;
                 parts: readonly {
                     tags?: string[] | undefined;
+                    scope?: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                        surface?: string | undefined;
+                        deviceKind?: string | undefined;
+                        syntheticData?: boolean | undefined;
+                        dependencies?: string | undefined;
+                        audioCaptured?: boolean | undefined;
+                        pacing?: string | undefined;
+                        asserted?: string[] | undefined;
+                        limitations?: string[] | undefined;
+                        declaredBy?: string | undefined;
+                        verified?: string[] | undefined;
+                        verifiedBy?: string | undefined;
+                        provenance?: {
+                            [x: string]: import("hono/utils/types").JSONValue;
+                            url: string;
+                            name?: string | undefined;
+                            rel?: string | undefined;
+                        }[] | undefined;
+                        extensions?: {
+                            [x: string]: import("hono/utils/types").JSONValue;
+                        } | undefined;
+                    } | undefined;
                     attachments?: {
                         [x: string]: import("hono/utils/types").JSONValue;
                         name: string;
@@ -83,6 +106,29 @@ export declare function createReportsExplorerApp(deps: ReportsExplorerDeps): imp
                         durationMs?: number | undefined;
                         description?: string | undefined;
                         omitted?: string | undefined;
+                        scope?: {
+                            [x: string]: import("hono/utils/types").JSONValue;
+                            surface?: string | undefined;
+                            deviceKind?: string | undefined;
+                            syntheticData?: boolean | undefined;
+                            dependencies?: string | undefined;
+                            audioCaptured?: boolean | undefined;
+                            pacing?: string | undefined;
+                            asserted?: string[] | undefined;
+                            limitations?: string[] | undefined;
+                            declaredBy?: string | undefined;
+                            verified?: string[] | undefined;
+                            verifiedBy?: string | undefined;
+                            provenance?: {
+                                [x: string]: import("hono/utils/types").JSONValue;
+                                url: string;
+                                name?: string | undefined;
+                                rel?: string | undefined;
+                            }[] | undefined;
+                            extensions?: {
+                                [x: string]: import("hono/utils/types").JSONValue;
+                            } | undefined;
+                        } | undefined;
                         tags?: string[] | undefined;
                         at?: {
                             [x: string]: import("hono/utils/types").JSONValue;
@@ -102,6 +148,29 @@ export declare function createReportsExplorerApp(deps: ReportsExplorerDeps): imp
                         durationMs?: number | undefined;
                         startedAtMs?: number | undefined;
                         detail?: string | undefined;
+                        scope?: {
+                            [x: string]: import("hono/utils/types").JSONValue;
+                            surface?: string | undefined;
+                            deviceKind?: string | undefined;
+                            syntheticData?: boolean | undefined;
+                            dependencies?: string | undefined;
+                            audioCaptured?: boolean | undefined;
+                            pacing?: string | undefined;
+                            asserted?: string[] | undefined;
+                            limitations?: string[] | undefined;
+                            declaredBy?: string | undefined;
+                            verified?: string[] | undefined;
+                            verifiedBy?: string | undefined;
+                            provenance?: {
+                                [x: string]: import("hono/utils/types").JSONValue;
+                                url: string;
+                                name?: string | undefined;
+                                rel?: string | undefined;
+                            }[] | undefined;
+                            extensions?: {
+                                [x: string]: import("hono/utils/types").JSONValue;
+                            } | undefined;
+                        } | undefined;
                         steps?: {
                             [x: string]: import("hono/utils/types").JSONValue;
                             name: string;
@@ -128,6 +197,29 @@ export declare function createReportsExplorerApp(deps: ReportsExplorerDeps): imp
                                 durationMs?: number | undefined;
                                 description?: string | undefined;
                                 omitted?: string | undefined;
+                                scope?: {
+                                    [x: string]: import("hono/utils/types").JSONValue;
+                                    surface?: string | undefined;
+                                    deviceKind?: string | undefined;
+                                    syntheticData?: boolean | undefined;
+                                    dependencies?: string | undefined;
+                                    audioCaptured?: boolean | undefined;
+                                    pacing?: string | undefined;
+                                    asserted?: string[] | undefined;
+                                    limitations?: string[] | undefined;
+                                    declaredBy?: string | undefined;
+                                    verified?: string[] | undefined;
+                                    verifiedBy?: string | undefined;
+                                    provenance?: {
+                                        [x: string]: import("hono/utils/types").JSONValue;
+                                        url: string;
+                                        name?: string | undefined;
+                                        rel?: string | undefined;
+                                    }[] | undefined;
+                                    extensions?: {
+                                        [x: string]: import("hono/utils/types").JSONValue;
+                                    } | undefined;
+                                } | undefined;
                                 tags?: string[] | undefined;
                                 at?: {
                                     [x: string]: import("hono/utils/types").JSONValue;
@@ -186,6 +278,29 @@ export declare function createReportsExplorerApp(deps: ReportsExplorerDeps): imp
                             durationMs?: number | undefined;
                             description?: string | undefined;
                             omitted?: string | undefined;
+                            scope?: {
+                                [x: string]: import("hono/utils/types").JSONValue;
+                                surface?: string | undefined;
+                                deviceKind?: string | undefined;
+                                syntheticData?: boolean | undefined;
+                                dependencies?: string | undefined;
+                                audioCaptured?: boolean | undefined;
+                                pacing?: string | undefined;
+                                asserted?: string[] | undefined;
+                                limitations?: string[] | undefined;
+                                declaredBy?: string | undefined;
+                                verified?: string[] | undefined;
+                                verifiedBy?: string | undefined;
+                                provenance?: {
+                                    [x: string]: import("hono/utils/types").JSONValue;
+                                    url: string;
+                                    name?: string | undefined;
+                                    rel?: string | undefined;
+                                }[] | undefined;
+                                extensions?: {
+                                    [x: string]: import("hono/utils/types").JSONValue;
+                                } | undefined;
+                            } | undefined;
                             tags?: string[] | undefined;
                             at?: {
                                 [x: string]: import("hono/utils/types").JSONValue;
@@ -254,6 +369,29 @@ export declare function createReportsExplorerApp(deps: ReportsExplorerDeps): imp
                             durationMs?: number | undefined;
                             description?: string | undefined;
                             omitted?: string | undefined;
+                            scope?: {
+                                [x: string]: import("hono/utils/types").JSONValue;
+                                surface?: string | undefined;
+                                deviceKind?: string | undefined;
+                                syntheticData?: boolean | undefined;
+                                dependencies?: string | undefined;
+                                audioCaptured?: boolean | undefined;
+                                pacing?: string | undefined;
+                                asserted?: string[] | undefined;
+                                limitations?: string[] | undefined;
+                                declaredBy?: string | undefined;
+                                verified?: string[] | undefined;
+                                verifiedBy?: string | undefined;
+                                provenance?: {
+                                    [x: string]: import("hono/utils/types").JSONValue;
+                                    url: string;
+                                    name?: string | undefined;
+                                    rel?: string | undefined;
+                                }[] | undefined;
+                                extensions?: {
+                                    [x: string]: import("hono/utils/types").JSONValue;
+                                } | undefined;
+                            } | undefined;
                             tags?: string[] | undefined;
                             at?: {
                                 [x: string]: import("hono/utils/types").JSONValue;
@@ -345,6 +483,29 @@ export declare function createReportsExplorerApp(deps: ReportsExplorerDeps): imp
                     readonly recordedAtMs: number;
                     readonly checks: readonly {
                         tags?: string[] | undefined;
+                        scope?: {
+                            [x: string]: import("hono/utils/types").JSONValue;
+                            surface?: string | undefined;
+                            deviceKind?: string | undefined;
+                            syntheticData?: boolean | undefined;
+                            dependencies?: string | undefined;
+                            audioCaptured?: boolean | undefined;
+                            pacing?: string | undefined;
+                            asserted?: string[] | undefined;
+                            limitations?: string[] | undefined;
+                            declaredBy?: string | undefined;
+                            verified?: string[] | undefined;
+                            verifiedBy?: string | undefined;
+                            provenance?: {
+                                [x: string]: import("hono/utils/types").JSONValue;
+                                url: string;
+                                name?: string | undefined;
+                                rel?: string | undefined;
+                            }[] | undefined;
+                            extensions?: {
+                                [x: string]: import("hono/utils/types").JSONValue;
+                            } | undefined;
+                        } | undefined;
                         attachments?: {
                             [x: string]: import("hono/utils/types").JSONValue;
                             name: string;
@@ -361,6 +522,29 @@ export declare function createReportsExplorerApp(deps: ReportsExplorerDeps): imp
                             durationMs?: number | undefined;
                             description?: string | undefined;
                             omitted?: string | undefined;
+                            scope?: {
+                                [x: string]: import("hono/utils/types").JSONValue;
+                                surface?: string | undefined;
+                                deviceKind?: string | undefined;
+                                syntheticData?: boolean | undefined;
+                                dependencies?: string | undefined;
+                                audioCaptured?: boolean | undefined;
+                                pacing?: string | undefined;
+                                asserted?: string[] | undefined;
+                                limitations?: string[] | undefined;
+                                declaredBy?: string | undefined;
+                                verified?: string[] | undefined;
+                                verifiedBy?: string | undefined;
+                                provenance?: {
+                                    [x: string]: import("hono/utils/types").JSONValue;
+                                    url: string;
+                                    name?: string | undefined;
+                                    rel?: string | undefined;
+                                }[] | undefined;
+                                extensions?: {
+                                    [x: string]: import("hono/utils/types").JSONValue;
+                                } | undefined;
+                            } | undefined;
                             tags?: string[] | undefined;
                             at?: {
                                 [x: string]: import("hono/utils/types").JSONValue;
@@ -380,6 +564,29 @@ export declare function createReportsExplorerApp(deps: ReportsExplorerDeps): imp
                             durationMs?: number | undefined;
                             startedAtMs?: number | undefined;
                             detail?: string | undefined;
+                            scope?: {
+                                [x: string]: import("hono/utils/types").JSONValue;
+                                surface?: string | undefined;
+                                deviceKind?: string | undefined;
+                                syntheticData?: boolean | undefined;
+                                dependencies?: string | undefined;
+                                audioCaptured?: boolean | undefined;
+                                pacing?: string | undefined;
+                                asserted?: string[] | undefined;
+                                limitations?: string[] | undefined;
+                                declaredBy?: string | undefined;
+                                verified?: string[] | undefined;
+                                verifiedBy?: string | undefined;
+                                provenance?: {
+                                    [x: string]: import("hono/utils/types").JSONValue;
+                                    url: string;
+                                    name?: string | undefined;
+                                    rel?: string | undefined;
+                                }[] | undefined;
+                                extensions?: {
+                                    [x: string]: import("hono/utils/types").JSONValue;
+                                } | undefined;
+                            } | undefined;
                             steps?: {
                                 [x: string]: import("hono/utils/types").JSONValue;
                                 name: string;
@@ -406,6 +613,29 @@ export declare function createReportsExplorerApp(deps: ReportsExplorerDeps): imp
                                     durationMs?: number | undefined;
                                     description?: string | undefined;
                                     omitted?: string | undefined;
+                                    scope?: {
+                                        [x: string]: import("hono/utils/types").JSONValue;
+                                        surface?: string | undefined;
+                                        deviceKind?: string | undefined;
+                                        syntheticData?: boolean | undefined;
+                                        dependencies?: string | undefined;
+                                        audioCaptured?: boolean | undefined;
+                                        pacing?: string | undefined;
+                                        asserted?: string[] | undefined;
+                                        limitations?: string[] | undefined;
+                                        declaredBy?: string | undefined;
+                                        verified?: string[] | undefined;
+                                        verifiedBy?: string | undefined;
+                                        provenance?: {
+                                            [x: string]: import("hono/utils/types").JSONValue;
+                                            url: string;
+                                            name?: string | undefined;
+                                            rel?: string | undefined;
+                                        }[] | undefined;
+                                        extensions?: {
+                                            [x: string]: import("hono/utils/types").JSONValue;
+                                        } | undefined;
+                                    } | undefined;
                                     tags?: string[] | undefined;
                                     at?: {
                                         [x: string]: import("hono/utils/types").JSONValue;
@@ -464,6 +694,29 @@ export declare function createReportsExplorerApp(deps: ReportsExplorerDeps): imp
                                 durationMs?: number | undefined;
                                 description?: string | undefined;
                                 omitted?: string | undefined;
+                                scope?: {
+                                    [x: string]: import("hono/utils/types").JSONValue;
+                                    surface?: string | undefined;
+                                    deviceKind?: string | undefined;
+                                    syntheticData?: boolean | undefined;
+                                    dependencies?: string | undefined;
+                                    audioCaptured?: boolean | undefined;
+                                    pacing?: string | undefined;
+                                    asserted?: string[] | undefined;
+                                    limitations?: string[] | undefined;
+                                    declaredBy?: string | undefined;
+                                    verified?: string[] | undefined;
+                                    verifiedBy?: string | undefined;
+                                    provenance?: {
+                                        [x: string]: import("hono/utils/types").JSONValue;
+                                        url: string;
+                                        name?: string | undefined;
+                                        rel?: string | undefined;
+                                    }[] | undefined;
+                                    extensions?: {
+                                        [x: string]: import("hono/utils/types").JSONValue;
+                                    } | undefined;
+                                } | undefined;
                                 tags?: string[] | undefined;
                                 at?: {
                                     [x: string]: import("hono/utils/types").JSONValue;
@@ -532,6 +785,29 @@ export declare function createReportsExplorerApp(deps: ReportsExplorerDeps): imp
                                 durationMs?: number | undefined;
                                 description?: string | undefined;
                                 omitted?: string | undefined;
+                                scope?: {
+                                    [x: string]: import("hono/utils/types").JSONValue;
+                                    surface?: string | undefined;
+                                    deviceKind?: string | undefined;
+                                    syntheticData?: boolean | undefined;
+                                    dependencies?: string | undefined;
+                                    audioCaptured?: boolean | undefined;
+                                    pacing?: string | undefined;
+                                    asserted?: string[] | undefined;
+                                    limitations?: string[] | undefined;
+                                    declaredBy?: string | undefined;
+                                    verified?: string[] | undefined;
+                                    verifiedBy?: string | undefined;
+                                    provenance?: {
+                                        [x: string]: import("hono/utils/types").JSONValue;
+                                        url: string;
+                                        name?: string | undefined;
+                                        rel?: string | undefined;
+                                    }[] | undefined;
+                                    extensions?: {
+                                        [x: string]: import("hono/utils/types").JSONValue;
+                                    } | undefined;
+                                } | undefined;
                                 tags?: string[] | undefined;
                                 at?: {
                                     [x: string]: import("hono/utils/types").JSONValue;