rea-agents 2.4.0 → 3.0.0

package/dist/domain/artifactInspection.js

@@ -0,0 +1,347 @@
+import { createHash } from "node:crypto";
+import canonicalize from "canonicalize";
+import { z } from "zod";
+import { artifactInventoryResultSchema, } from "./artifactGraph.js";
+import { evidenceSchema, parseEvidence } from "./evidence.js";
+import { jsonValueSchema } from "./jsonValue.js";
+const boundedTextSchema = z.string().min(1).max(4_096);
+const evidenceIdSchema = z.string().regex(/^ev_[a-f0-9]{64}$/u);
+const artifactIdSchema = z.string().regex(/^art_[a-f0-9]{64}$/u);
+const inspectionLimitsSchema = z.strictObject({
+    max_observations: z.number().int().min(1).max(500).default(100),
+    max_relationships: z.number().int().min(1).max(500).default(100),
+    max_hypotheses: z.number().int().min(1).max(100).default(20),
+    max_unexplored_branches: z.number().int().min(1).max(100).default(20),
+    max_next_probes: z.number().int().min(1).max(50).default(20),
+    max_substeps: z.literal(1).default(1),
+});
+export const artifactInspectionLimitsSchema = inspectionLimitsSchema;
+const inspectionObservationSchema = z.strictObject({
+    observation_id: z.string().regex(/^aio_[a-f0-9]{64}$/u),
+    kind: z.enum(["root-manifest", "artifact", "occurrence", "integrity"]),
+    subject: boundedTextSchema,
+    value: jsonValueSchema,
+    evidence_id: evidenceIdSchema,
+});
+const inspectionRelationshipSchema = z.strictObject({
+    relationship_id: z.string().regex(/^air_[a-f0-9]{64}$/u),
+    relation: z.enum([
+        "contains",
+        "extracts",
+        "slice-of",
+        "embeds",
+        "loads",
+        "maps-source",
+        "derived-from",
+    ]),
+    source_artifact_id: artifactIdSchema,
+    target_artifact_id: artifactIdSchema,
+    occurrence_id: z.string().regex(/^occ_[a-f0-9]{64}$/u),
+    logical_path: boundedTextSchema.nullable(),
+    evidence_id: evidenceIdSchema,
+});
+const inspectionHypothesisSchema = z.strictObject({
+    hypothesis_id: z.string().regex(/^aih_[a-f0-9]{64}$/u),
+    statement: boundedTextSchema,
+    confidence: z.enum(["medium", "low"]),
+    basis_evidence_ids: z.array(evidenceIdSchema).min(1).max(8),
+    limitation: boundedTextSchema,
+});
+const inspectionContradictionSchema = z.strictObject({
+    contradiction_id: z.string().regex(/^aic_[a-f0-9]{64}$/u),
+    statement: boundedTextSchema,
+    occurrence_id: z.string().regex(/^occ_[a-f0-9]{64}$/u),
+    declared_sha256: z.string().regex(/^[a-f0-9]{64}$/u),
+    observed_sha256: z.string().regex(/^[a-f0-9]{64}$/u),
+    evidence_id: evidenceIdSchema,
+});
+const nextProbeSchema = z.strictObject({
+    operation: z.string().min(1).max(128),
+    rationale: boundedTextSchema,
+    authority: z.enum([
+        "artifact-bytes",
+        "managed-static-analysis",
+        "native-analysis-provider",
+        "ast-static-analysis",
+    ]),
+});
+const unexploredBranchSchema = z.strictObject({
+    branch_id: z.string().regex(/^aib_[a-f0-9]{64}$/u),
+    reason: z.enum([
+        "page-limit",
+        "format-specific-analysis-required",
+        "unknown-format",
+    ]),
+    detail: boundedTextSchema,
+    next_probe: nextProbeSchema.nullable(),
+    evidence_id: evidenceIdSchema,
+});
+/** Provider-neutral inspection result with its atomic source Evidence. */
+export const artifactInspectionResultSchema = z.strictObject({
+    schema_version: z.literal(1),
+    inspection_id: z.string().regex(/^ai_[a-f0-9]{64}$/u),
+    subject: z.strictObject({
+        manifest_id: z.string().regex(/^agm_[a-f0-9]{64}$/u),
+        root_artifact_id: artifactIdSchema,
+        root_sha256: z.string().regex(/^[a-f0-9]{64}$/u),
+        root_format: z.string().min(1).max(128),
+    }),
+    substeps: z
+        .array(z.strictObject({
+        substep_id: z.string().regex(/^ais_[a-f0-9]{64}$/u),
+        operation: z.literal("inventory_artifact"),
+        status: z.literal("completed"),
+        evidence_id: evidenceIdSchema,
+        evidence: evidenceSchema,
+    }))
+        .min(1)
+        .max(1),
+    observations: z.array(inspectionObservationSchema).max(500),
+    derived_relationships: z.array(inspectionRelationshipSchema).max(500),
+    hypotheses: z.array(inspectionHypothesisSchema).max(100),
+    contradictions: z.array(inspectionContradictionSchema).max(100),
+    unexplored_branches: z.array(unexploredBranchSchema).max(100),
+    next_probes: z.array(nextProbeSchema).max(50),
+    coverage: z.strictObject({
+        status: z.enum(["complete-within-substeps", "partial", "truncated"]),
+        substeps_completed: z.literal(1),
+        observations_retained: z.number().int().min(0),
+        observations_omitted: z.number().int().min(0),
+        relationships_retained: z.number().int().min(0),
+        relationships_omitted: z.number().int().min(0),
+        hypotheses_retained: z.number().int().min(0),
+        hypotheses_omitted: z.number().int().min(0),
+        unexplored_branches_retained: z.number().int().min(0),
+        unexplored_branches_omitted: z.number().int().min(0),
+        next_probes_retained: z.number().int().min(0),
+        next_probes_omitted: z.number().int().min(0),
+    }),
+    evidence_links: z.array(evidenceIdSchema).min(1).max(1),
+    limitations: z.array(boundedTextSchema).max(1_000),
+});
+/** Project one successful inventory Evidence record into an inspection report. */
+export const createArtifactInspection = (inventoryInput, limits) => {
+    const inventoryEvidence = parseInventoryEvidence(inventoryInput);
+    const inventory = artifactInventoryResultSchema.parse(inventoryEvidence.normalized_result);
+    const observations = allObservations(inventory, inventoryEvidence.evidence_id);
+    const relationships = allRelationships(inventory, inventoryEvidence.evidence_id);
+    const hypotheses = allHypotheses(inventory, inventoryEvidence.evidence_id);
+    const nextProbes = probesFor(inventory);
+    const branches = allUnexploredBranches(inventory, inventoryEvidence.evidence_id, nextProbes);
+    const retained = {
+        observations: observations.slice(0, limits.max_observations),
+        relationships: relationships.slice(0, limits.max_relationships),
+        hypotheses: hypotheses.slice(0, limits.max_hypotheses),
+        branches: branches.slice(0, limits.max_unexplored_branches),
+        probes: nextProbes.slice(0, limits.max_next_probes),
+    };
+    const omissions = {
+        observations: observations.length - retained.observations.length,
+        relationships: relationships.length - retained.relationships.length,
+        hypotheses: hypotheses.length - retained.hypotheses.length,
+        branches: branches.length - retained.branches.length,
+        probes: nextProbes.length - retained.probes.length,
+    };
+    const semantic = {
+        schema_version: 1,
+        subject: {
+            manifest_id: inventory.manifest.manifest_id,
+            root_artifact_id: inventory.manifest.root_artifact_id,
+            root_sha256: inventory.manifest.root_sha256,
+            root_format: inventory.manifest.root_format,
+        },
+        substeps: [
+            {
+                substep_id: `ais_${digestCanonical({
+                    operation: "inventory_artifact",
+                    evidence_id: inventoryEvidence.evidence_id,
+                })}`,
+                operation: "inventory_artifact",
+                status: "completed",
+                evidence_id: inventoryEvidence.evidence_id,
+                evidence: inventoryEvidence,
+            },
+        ],
+        observations: retained.observations,
+        derived_relationships: retained.relationships,
+        hypotheses: retained.hypotheses,
+        contradictions: contradictions(inventory, inventoryEvidence.evidence_id),
+        unexplored_branches: retained.branches,
+        next_probes: retained.probes,
+        coverage: {
+            status: inspectionCoverage(inventory, omissions),
+            substeps_completed: 1,
+            observations_retained: retained.observations.length,
+            observations_omitted: omissions.observations,
+            relationships_retained: retained.relationships.length,
+            relationships_omitted: omissions.relationships,
+            hypotheses_retained: retained.hypotheses.length,
+            hypotheses_omitted: omissions.hypotheses,
+            unexplored_branches_retained: retained.branches.length,
+            unexplored_branches_omitted: omissions.branches,
+            next_probes_retained: retained.probes.length,
+            next_probes_omitted: omissions.probes,
+        },
+        evidence_links: [inventoryEvidence.evidence_id],
+        limitations: uniqueSorted([
+            ...inventory.limitations,
+            "Inspection derives bounded static hypotheses and next probes; it does not execute the artifact or claim format-specific semantics.",
+        ]),
+    };
+    return artifactInspectionResultSchema.parse({
+        ...semantic,
+        inspection_id: `ai_${digestCanonical(semantic)}`,
+    });
+};
+const parseInventoryEvidence = (input) => {
+    const evidence = parseEvidence(input);
+    if (evidence.operation !== "inventory_artifact")
+        throw new TypeError("Artifact inspection substep requires inventory_artifact Evidence");
+    return evidence;
+};
+const allObservations = (inventory, evidenceId) => [
+    observation("root-manifest", inventory.manifest.root_artifact_id, inventory.manifest, evidenceId),
+    ...inventory.nodes.items.map((node) => observation("artifact", node.artifact_id, node, evidenceId)),
+    ...inventory.occurrences.items.map((occurrence) => observation("occurrence", occurrence.occurrence_id, occurrence, evidenceId)),
+    ...inventory.integrity_contradictions.map((value) => observation("integrity", value.contradiction_id, value, evidenceId)),
+];
+const observation = (kind, subject, value, evidenceId) => {
+    const semantic = {
+        kind,
+        subject,
+        value: jsonValueSchema.parse(value),
+        evidence_id: evidenceId,
+    };
+    return { observation_id: `aio_${digestCanonical(semantic)}`, ...semantic };
+};
+const allRelationships = (inventory, evidenceId) => inventory.edges.items.map((edge) => {
+    const semantic = {
+        relation: edge.relation,
+        source_artifact_id: edge.parent_artifact_id,
+        target_artifact_id: edge.child_artifact_id,
+        occurrence_id: edge.occurrence_id,
+        logical_path: edge.logical_path,
+        evidence_id: evidenceId,
+    };
+    return {
+        relationship_id: `air_${digestCanonical(semantic)}`,
+        ...semantic,
+    };
+});
+const allHypotheses = (inventory, evidenceId) => {
+    const statements = inventory.manifest.root_format === "pe"
+        ? [
+            "The PE artifact may contain managed CLI metadata or native code; inventory bytes alone do not distinguish them.",
+        ]
+        : ["asar", "javascript-bundle"].includes(inventory.manifest.root_format)
+            ? [
+                "The artifact may contain a recoverable JavaScript application graph.",
+            ]
+            : [];
+    return statements.map((statement) => {
+        const semantic = {
+            statement,
+            confidence: "low",
+            basis_evidence_ids: [evidenceId],
+            limitation: "Format classification proposes a bounded follow-up; it is not semantic proof.",
+        };
+        return { hypothesis_id: `aih_${digestCanonical(semantic)}`, ...semantic };
+    });
+};
+const contradictions = (inventory, evidenceId) => inventory.integrity_contradictions.map((value) => {
+    const semantic = {
+        statement: `Declared integrity for ${value.logical_path} contradicts observed bytes.`,
+        occurrence_id: value.occurrence_id,
+        declared_sha256: value.declared_sha256,
+        observed_sha256: value.observed_sha256,
+        evidence_id: evidenceId,
+    };
+    return {
+        contradiction_id: `aic_${digestCanonical(semantic)}`,
+        ...semantic,
+    };
+});
+const probesFor = (inventory) => {
+    const format = inventory.manifest.root_format;
+    if (["asar", "javascript-bundle", "directory"].includes(format))
+        return [
+            {
+                operation: "analyze_javascript_application",
+                rationale: "Recover bounded JavaScript modules, source maps, Electron boundaries, and application relationships.",
+                authority: "ast-static-analysis",
+            },
+        ];
+    if (format === "pe")
+        return [
+            {
+                operation: "inspect_managed_artifact",
+                rationale: "Check execution-free CLI metadata before choosing a deep native provider.",
+                authority: "managed-static-analysis",
+            },
+            {
+                operation: "open_binary",
+                rationale: "Open as native code only when managed inspection reports a native or mixed boundary.",
+                authority: "native-analysis-provider",
+            },
+        ];
+    if (["mach-o", "mach-o-universal", "elf"].includes(format))
+        return [
+            {
+                operation: "open_binary",
+                rationale: "Bind one deep native provider before function-level analysis.",
+                authority: "native-analysis-provider",
+            },
+        ];
+    if (format === "plist")
+        return [
+            {
+                operation: "inspect_plist",
+                rationale: "Parse property-list values without executing the artifact.",
+                authority: "artifact-bytes",
+            },
+        ];
+    return [];
+};
+const allUnexploredBranches = (inventory, evidenceId, nextProbes) => {
+    const pages = [
+        ["nodes", inventory.nodes.next_offset],
+        ["occurrences", inventory.occurrences.next_offset],
+        ["relationships", inventory.edges.next_offset],
+    ];
+    const branches = pages.flatMap(([collection, nextOffset]) => nextOffset === null
+        ? []
+        : [
+            branch("page-limit", `${collection} continue at offset ${String(nextOffset)}.`, null, evidenceId),
+        ]);
+    branches.push(...nextProbes.map((probe) => branch("format-specific-analysis-required", `${probe.operation} was not run by provider-neutral artifact inspection.`, probe, evidenceId)));
+    if (inventory.manifest.root_format === "unknown")
+        branches.push(branch("unknown-format", "Artifact bytes did not match an admitted format classifier.", null, evidenceId));
+    return branches;
+};
+const branch = (reason, detail, nextProbe, evidenceId) => {
+    const semantic = {
+        reason,
+        detail,
+        next_probe: nextProbe,
+        evidence_id: evidenceId,
+    };
+    return { branch_id: `aib_${digestCanonical(semantic)}`, ...semantic };
+};
+const inspectionCoverage = (inventory, omissions) => {
+    if (Object.values(omissions).some((count) => count > 0))
+        return "truncated";
+    return [
+        inventory.nodes.next_offset,
+        inventory.occurrences.next_offset,
+        inventory.edges.next_offset,
+    ].some((offset) => offset !== null)
+        ? "partial"
+        : "complete-within-substeps";
+};
+const digestCanonical = (value) => {
+    const encoded = canonicalize(value);
+    if (encoded === undefined)
+        throw new TypeError("Artifact inspection could not canonicalize");
+    return createHash("sha256").update(encoded).digest("hex");
+};
+const uniqueSorted = (values) => [...new Set(values)].sort((left, right) => left < right ? -1 : left > right ? 1 : 0);

package/dist/domain/browserCaptureComparison.js

@@ -0,0 +1,82 @@
+import { z } from "zod";
+import { browserScenarioDiffSchema, compareBrowserScenarios, compareBrowserScenariosInputSchema, } from "./browserScenarioDiff.js";
+import { compareWebCaptures, captureSnapshotSchema, webCaptureDiffSchema, } from "./webCaptureDiff.js";
+/** Top-level MCP shape for legacy page or step-indexed scenario comparison. */
+export const browserCaptureComparisonWireSchema = z
+    .strictObject({
+    before: captureSnapshotSchema
+        .optional()
+        .describe("Earlier passive web-page capture; pair with after."),
+    after: captureSnapshotSchema
+        .optional()
+        .describe("Later passive web-page capture; pair with before."),
+    before_scenario: compareBrowserScenariosInputSchema.shape.before_scenario
+        .optional()
+        .describe("Earlier browser scenario capture; pair with after_scenario."),
+    after_scenario: compareBrowserScenariosInputSchema.shape.after_scenario
+        .optional()
+        .describe("Later browser scenario capture; pair with before_scenario."),
+    normalization: compareBrowserScenariosInputSchema.shape.normalization.describe("Scenario-only exact-literal normalization policy."),
+    max_changes: z
+        .number()
+        .int()
+        .min(1)
+        .max(20_000)
+        .default(2_000)
+        .describe("Maximum normalized change records to retain."),
+})
+    .superRefine((input, context) => {
+    const hasPassive = input.before !== undefined || input.after !== undefined;
+    const hasScenario = input.before_scenario !== undefined || input.after_scenario !== undefined;
+    if (hasPassive === hasScenario)
+        context.addIssue({
+            code: "custom",
+            message: "Provide exactly one complete pair: before/after or before_scenario/after_scenario",
+        });
+    if (hasPassive && (input.before === undefined || input.after === undefined))
+        context.addIssue({
+            code: "custom",
+            message: "Passive comparison requires both before and after",
+        });
+    if (hasScenario &&
+        (input.before_scenario === undefined ||
+            input.after_scenario === undefined))
+        context.addIssue({
+            code: "custom",
+            message: "Browser scenario comparison requires both before_scenario and after_scenario",
+        });
+    if (hasPassive && input.normalization.rules.length > 0)
+        context.addIssue({
+            code: "custom",
+            path: ["normalization"],
+            message: "Literal normalization rules apply only to browser scenario captures",
+        });
+});
+/** Parsed legacy page snapshots or step-indexed browser scenarios. */
+export const browserCaptureComparisonInputSchema = browserCaptureComparisonWireSchema.transform((input) => {
+    if (input.before_scenario !== undefined &&
+        input.after_scenario !== undefined)
+        return {
+            before_scenario: input.before_scenario,
+            after_scenario: input.after_scenario,
+            normalization: input.normalization,
+            max_changes: input.max_changes,
+        };
+    if (input.before !== undefined && input.after !== undefined)
+        return {
+            before: input.before,
+            after: input.after,
+            max_changes: input.max_changes,
+        };
+    throw new TypeError("Capture comparison pair refinement failed");
+});
+/** Result from passive page or browser scenario comparison. */
+export const browserCaptureComparisonSchema = z.union([
+    browserScenarioDiffSchema,
+    webCaptureDiffSchema,
+]);
+/** Dispatch a parsed capture comparison to its pure domain comparator. */
+export const compareBrowserCaptures = (input) => isScenarioComparison(input)
+    ? compareBrowserScenarios(input)
+    : compareWebCaptures(input);
+const isScenarioComparison = (input) => "before_scenario" in input;

package/dist/domain/browserObservation.js

@@ -201,9 +201,16 @@ export const inspectWebPageInputSchema = z
     websocket_shape_approved: z.boolean().default(false),
     include_script_sources: z.boolean().default(false),
     include_storage_keys: z.boolean().default(false),
+    include_storage_fingerprints: z.boolean().default(false),
     limits: browserInspectionLimitsSchema.default(DEFAULT_BROWSER_INSPECTION_LIMITS),
 })
     .superRefine((input, context) => {
+    if (input.include_storage_fingerprints && !input.include_storage_keys)
+        context.addIssue({
+            code: "custom",
+            path: ["include_storage_fingerprints"],
+            message: "Storage fingerprints require storage key capture",
+        });
     if (input.limits.max_script_source_bytes >
         input.limits.max_total_script_source_bytes)
         context.addIssue({
@@ -261,7 +268,7 @@ export const inspectWebPageInputSchema = z
             message: "Per-field accessibility text limit cannot exceed the total text limit",
         });
 });
-const sanitizedBrowserUrlSchema = z.object({
+export const sanitizedBrowserUrlSchema = z.object({
     url: z.string().max(MAX_SANITIZED_BROWSER_URL_CHARS),
     origin: z.string().max(2_048).nullable(),
     query_parameter_names: z

package/dist/domain/browserObservationErrors.js

@@ -0,0 +1 @@
+export {};

package/dist/domain/browserObservationSchemas.js

@@ -57,6 +57,12 @@ const browserAxNodeSchema = z.object({
     name: z.string().nullable(),
     description: z.string().nullable(),
     ignored: z.boolean(),
+    states: z
+        .array(z.object({
+        name: z.string(),
+        value: z.union([z.boolean(), z.number(), z.string()]),
+    }))
+        .default([]),
 });
 const browserScriptSourceSchema = z.discriminatedUnion("included", [
     z.object({ included: z.literal(false), reason: z.string() }),
@@ -280,6 +286,26 @@ export const webPageInspectionSchema = z.object({
         session_storage_keys: z.array(z.string()),
         indexed_db_names: z.array(z.string()),
         cache_names: z.array(z.string()),
+        content_fingerprints: z
+            .array(z.object({
+            scope: z.enum([
+                "cookie",
+                "local_storage",
+                "session_storage",
+                "indexed_db_schema",
+                "indexed_db_record",
+                "cache_entry",
+            ]),
+            identity_sha256: z.string().regex(/^[a-f0-9]{64}$/u),
+            value_sha256: z
+                .string()
+                .regex(/^[a-f0-9]{64}$/u)
+                .nullable(),
+            complete: z.boolean(),
+        }))
+            .default([]),
+        fingerprint_algorithm: z.literal("sha256").default("sha256"),
+        fingerprints_complete: z.boolean().default(false),
         values_redacted: z.literal(true),
     }),
     limitations: z.array(z.string()),

package/dist/domain/browserScenario.js

@@ -0,0 +1,165 @@
+import { z } from "zod";
+import { BROWSER_SCENARIO_LIMITS, browserScenarioActionSchema, browserScenarioAllowedOriginsSchema, browserScenarioBrowserSchema, browserScenarioCaptureLimitsSchema, browserScenarioCaptureSchema, browserScenarioEnvironmentSchema, browserScenarioRedactionSchema, browserScenarioRequestReplaySchema, browserScenarioSecretSchema, browserScenarioStorageSchema, browserScenarioUrlSchema, } from "./browserScenarioValues.js";
+export { BROWSER_SCENARIO_LIMITS, browserScenarioActionSchema, browserScenarioUrlSchema, browserScenarioValueSchema, } from "./browserScenarioValues.js";
+const scenarioShapeSchema = z.strictObject({
+    schema_version: z.literal(1),
+    browser: browserScenarioBrowserSchema,
+    start_url: browserScenarioUrlSchema,
+    allowed_origins: browserScenarioAllowedOriginsSchema,
+    environment: browserScenarioEnvironmentSchema,
+    actions: z
+        .array(browserScenarioActionSchema)
+        .min(1)
+        .max(BROWSER_SCENARIO_LIMITS.actions),
+    storage: browserScenarioStorageSchema,
+    request_replay: browserScenarioRequestReplaySchema,
+    secrets: z
+        .array(browserScenarioSecretSchema)
+        .max(BROWSER_SCENARIO_LIMITS.secrets)
+        .default([]),
+    redaction: browserScenarioRedactionSchema,
+    capture: browserScenarioCaptureSchema,
+    limits: browserScenarioCaptureLimitsSchema,
+    approved: z.literal(true),
+});
+const addIssue = (context, path, message) => context.addIssue({ code: "custom", path, message });
+const assertUnique = (values, path, label, context) => {
+    if (new Set(values).size !== values.length)
+        addIssue(context, path, `${label} must be unique`);
+};
+const originFor = (destination) => new URL(destination.url).origin;
+const assertAllowedDestination = (destination, allowedOrigins, path, context) => {
+    if (!allowedOrigins.has(originFor(destination)))
+        addIssue(context, path, `URL origin ${originFor(destination)} is not declared in allowed_origins`);
+};
+const secretReferencesInValue = (value) => (value?.source === "secret" ? [value.secret_id] : []);
+const destinationSecretReferences = (destination) => destination.query.flatMap(({ value }) => secretReferencesInValue(value));
+const actionSecretReferences = (action) => {
+    if (action.action === "fill" || action.action === "select_option")
+        return secretReferencesInValue(action.value);
+    if (action.action === "goto")
+        return destinationSecretReferences(action.destination);
+    return [];
+};
+const validateStorage = (scenario, allowedOrigins, context) => {
+    const references = [];
+    scenario.storage.cookies.forEach((cookie, index) => {
+        assertAllowedDestination(cookie.destination, allowedOrigins, ["storage", "cookies", index, "destination"], context);
+        references.push(...secretReferencesInValue(cookie.value));
+        references.push(...destinationSecretReferences(cookie.destination));
+    });
+    for (const collection of ["local_storage", "session_storage"])
+        scenario.storage[collection].forEach((storage, index) => {
+            if (!allowedOrigins.has(storage.origin))
+                addIssue(context, ["storage", collection, index, "origin"], `Storage origin ${storage.origin} is not declared in allowed_origins`);
+            for (const entry of storage.entries)
+                references.push(...secretReferencesInValue(entry.value));
+        });
+    return references;
+};
+const SENSITIVE_HEADERS = new Set([
+    "authorization",
+    "cookie",
+    "proxy-authorization",
+    "set-cookie",
+]);
+const FORBIDDEN_REPLAY_HEADERS = new Set([
+    "content-length",
+    "location",
+    "transfer-encoding",
+]);
+const validateRequestReplay = (scenario, allowedOrigins, context) => {
+    if (scenario.request_replay.mode === "disabled")
+        return [];
+    assertUnique(scenario.request_replay.routes.map(({ route_id: id }) => id), ["request_replay", "routes"], "Replay route IDs", context);
+    assertUnique(scenario.request_replay.routes.map(({ method, request }) => `${method} ${request.url}?${request.query
+        .map(({ name, value }) => value.source === "secret"
+        ? `${name}=\${secret:${value.secret_id}}`
+        : `${name}=${value.value}`)
+        .join("&")}`), ["request_replay", "routes"], "Replay request matchers", context);
+    const references = [];
+    scenario.request_replay.routes.forEach((route, routeIndex) => {
+        assertAllowedDestination(route.request, allowedOrigins, ["request_replay", "routes", routeIndex, "request"], context);
+        references.push(...destinationSecretReferences(route.request));
+        if (route.response.kind === "redirect") {
+            assertAllowedDestination(route.response.destination, allowedOrigins, ["request_replay", "routes", routeIndex, "response", "destination"], context);
+            references.push(...destinationSecretReferences(route.response.destination));
+            return;
+        }
+        assertUnique(route.response.headers.map(({ name }) => name.toLowerCase()), ["request_replay", "routes", routeIndex, "response", "headers"], "Replay response header names", context);
+        route.response.headers.forEach((header, headerIndex) => {
+            if (FORBIDDEN_REPLAY_HEADERS.has(header.name))
+                addIssue(context, [
+                    "request_replay",
+                    "routes",
+                    routeIndex,
+                    "response",
+                    "headers",
+                    headerIndex,
+                ], `Replay header ${header.name} must be modeled by the provider`);
+            if (SENSITIVE_HEADERS.has(header.name) &&
+                header.value.source === "literal")
+                addIssue(context, [
+                    "request_replay",
+                    "routes",
+                    routeIndex,
+                    "response",
+                    "headers",
+                    headerIndex,
+                    "value",
+                ], `Credential header ${header.name} requires a declared secret`);
+            references.push(...secretReferencesInValue(header.value));
+        });
+        references.push(...secretReferencesInValue(route.response.body));
+    });
+    return references;
+};
+const validateSecretReferences = (scenario, references, context) => {
+    const declared = new Set(scenario.secrets.map(({ secret_id: id }) => id));
+    for (const reference of references)
+        if (!declared.has(reference))
+            addIssue(context, ["secrets"], `Secret reference ${reference} is not declared`);
+    const used = new Set(references);
+    scenario.secrets.forEach(({ secret_id: id }, index) => {
+        if (!used.has(id))
+            addIssue(context, ["secrets", index, "secret_id"], `Secret declaration ${id} is unused`);
+    });
+};
+const validateRedactionCoverage = (scenario, context) => {
+    const redactedQueries = new Set(scenario.redaction.query_parameter_names);
+    const destinations = [scenario.start_url];
+    for (const action of scenario.actions)
+        if (action.action === "goto")
+            destinations.push(action.destination);
+    for (const cookie of scenario.storage.cookies)
+        destinations.push(cookie.destination);
+    if (scenario.request_replay.mode === "exact")
+        for (const route of scenario.request_replay.routes) {
+            destinations.push(route.request);
+            if (route.response.kind === "redirect")
+                destinations.push(route.response.destination);
+        }
+    for (const destination of destinations)
+        for (const query of destination.query)
+            if (query.value.source === "secret" &&
+                !redactedQueries.has(query.name.toLowerCase()))
+                addIssue(context, ["redaction", "query_parameter_names"], `Secret query parameter ${query.name} must be declared for redaction`);
+};
+const validateBrowserScenario = (scenario, context) => {
+    const allowedOrigins = new Set(scenario.allowed_origins);
+    assertAllowedDestination(scenario.start_url, allowedOrigins, ["start_url"], context);
+    assertUnique(scenario.actions.map(({ step_id: id }) => id), ["actions"], "Action step IDs", context);
+    assertUnique(scenario.secrets.map(({ secret_id: id }) => id), ["secrets"], "Secret IDs", context);
+    assertUnique(scenario.secrets.map(({ environment_variable: name }) => name), ["secrets"], "Secret environment variables", context);
+    const references = scenario.actions.flatMap(actionSecretReferences);
+    for (const [index, action] of scenario.actions.entries())
+        if (action.action === "goto")
+            assertAllowedDestination(action.destination, allowedOrigins, ["actions", index, "destination"], context);
+    references.push(...destinationSecretReferences(scenario.start_url));
+    references.push(...validateStorage(scenario, allowedOrigins, context));
+    references.push(...validateRequestReplay(scenario, allowedOrigins, context));
+    validateSecretReferences(scenario, references, context);
+    validateRedactionCoverage(scenario, context);
+};
+/** Strict provider-neutral contract for one bounded browser capture scenario. */
+export const browserScenarioSchema = scenarioShapeSchema.superRefine(validateBrowserScenario);