rea-agents 4.0.0 → 4.1.0

package/dist/domain/analysisErrorProjection.js

@@ -1,5 +1,14 @@
-import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, AnalysisInputError, AnalysisTimeoutError, ArtifactOperationError, BinaryTargetError, BrowserObservationError, EvidenceFileError, EvidenceReferenceError, HopperCancelledError, HopperProcessError, HopperRemoteError, HopperTimeoutError, ProviderAdapterError, ProviderSelectionError, UnknownRegistryError, } from "./errors.js";
 import { analysisErrorCategory, analysisErrorRemediationAction, analysisErrorUserMessage, assertKnownAnalysisErrorTag, } from "./analysisErrorPresentation.js";
+import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, AnalysisInputError, AnalysisOutputError, AnalysisTimeoutError, } from "./analysisErrorCore.js";
+import { ArtifactOperationError } from "./artifactOperationError.js";
+import { BinaryTargetError } from "./configurationErrors.js";
+import { BrowserObservationError } from "./browserObservationError.js";
+import { EvidenceFileError, EvidenceReferenceError } from "./evidenceErrors.js";
+import { HopperCancelledError, HopperProcessError, HopperRemoteError, HopperTimeoutError, } from "./hopperErrors.js";
+import { ProviderAdapterError } from "./providerAdapterError.js";
+import { ProviderSelectionError } from "./providerSelectionError.js";
+import { UnknownRegistryError } from "./unknownRegistryError.js";
+import {} from "./analysisErrorBase.js";
 /** Project expected failures into exhaustive, secret-safe caller fields. */
 export const projectAnalysisError = (error) => {
     assertKnownAnalysisErrorTag(error._tag);
@@ -111,6 +120,8 @@ const errorDetails = (error) => requestErrorDetails(error) ??
     providerErrorDetails(error) ??
     lifecycleErrorDetails(error);
 const requestErrorDetails = (error) => {
+    if (error instanceof AnalysisOutputError)
+        return { operation: error.operation, reason: error.reason };
     if (error instanceof AnalysisInputError && error.issues.length > 0)
         return {
             operation: error.operation,
@@ -154,7 +165,11 @@ const artifactStateErrorDetails = (error) => {
 };
 const providerErrorDetails = (error) => {
     if (error instanceof AnalysisCapabilityUnavailableError)
-        return { provider_id: error.providerId, operation: error.operation };
+        return {
+            provider_id: error.providerId,
+            operation: error.operation,
+            reason: error.reason,
+        };
     if (error instanceof ProviderSelectionError)
         return {
             operation: error.operation,
@@ -261,7 +276,13 @@ const lifecycleErrorDetails = (error) => {
         error.userCategory === "cancelled")
         return { operation: "process_capture", cleanup: "complete" };
     if (error instanceof BinaryTargetError)
-        return { path: error.path };
+        return {
+            path: error.path,
+            reason: error.reason,
+            ...(error.constraint === undefined
+                ? {}
+                : { constraint: error.constraint }),
+        };
     return undefined;
 };
 const RETRYABLE_CODES = new Set([

package/dist/domain/analysisSnapshot.js

@@ -14,6 +14,7 @@ const formatSchema = z.enum([
     "elf",
     "pe",
     "dos-mz",
+    "dos-com",
     "zip",
     "ipa",
     "apk",

package/dist/domain/androidAnalysis.js

@@ -0,0 +1,141 @@
+import { z } from "zod";
+const target = {
+    path: z
+        .string()
+        .min(1)
+        .describe("Local APK path; the target is never executed"),
+};
+const classTarget = {
+    ...target,
+    class_name: z.string().min(1).describe("Exact fully qualified class name"),
+};
+/** Caller intent for static Android inspection, independent of its engine. */
+export const androidInputSchemas = {
+    inspect_android_package: z.strictObject(target),
+    search_android_classes: z.strictObject({
+        ...target,
+        query: z
+            .string()
+            .describe("Case-sensitive class-name substring; empty lists all classes"),
+    }),
+    inspect_android_class: z.strictObject(classTarget),
+    inspect_android_method: z.strictObject({
+        ...classTarget,
+        method_name: z.string().min(1),
+        overload_index: z
+            .number()
+            .int()
+            .nonnegative()
+            .optional()
+            .describe("Explicit index among same-name methods; required when ambiguous"),
+    }),
+    trace_android_references: z.strictObject({
+        ...classTarget,
+        method_name: z
+            .string()
+            .min(1)
+            .optional()
+            .describe("Omit for class references; ambiguous overloaded methods are unsupported"),
+    }),
+};
+/** Validate operation and input together so their types remain correlated. */
+export const androidRequestSchema = z.discriminatedUnion("operation", [
+    z.strictObject({
+        operation: z.literal("inspect_android_package"),
+        input: androidInputSchemas.inspect_android_package,
+    }),
+    z.strictObject({
+        operation: z.literal("search_android_classes"),
+        input: androidInputSchemas.search_android_classes,
+    }),
+    z.strictObject({
+        operation: z.literal("inspect_android_class"),
+        input: androidInputSchemas.inspect_android_class,
+    }),
+    z.strictObject({
+        operation: z.literal("inspect_android_method"),
+        input: androidInputSchemas.inspect_android_method,
+    }),
+    z.strictObject({
+        operation: z.literal("trace_android_references"),
+        input: androidInputSchemas.trace_android_references,
+    }),
+]);
+const textCoverage = z.strictObject({
+    status: z.enum(["complete", "partial"]),
+    text: z.string(),
+    reported_total_bytes: z.number().int().nonnegative().nullable(),
+});
+const method = z.strictObject({
+    name: z.string(),
+    reported_signature: z.string(),
+    overload_index: z.number().int().nonnegative(),
+    is_constructor: z.boolean(),
+    dex_descriptor: z.null(),
+});
+const engine = z.strictObject({
+    name: z.string().min(1),
+    version: z.string().nullable(),
+    artifact_sha256: z.string().regex(/^[a-f0-9]{64}$/u),
+    source_revision: z.string().nullable(),
+    worker_count: z.number().int().positive(),
+    heap_limit_mib: z.number().int().positive().nullable(),
+});
+const common = { engine };
+/** Portable observations with explicit decompiler and identity limitations. */
+export const androidResultSchemas = {
+    inspect_android_package: z.strictObject({
+        ...common,
+        package_name: z.string().nullable(),
+        version_name: z.string().nullable(),
+        version_code: z.string().nullable(),
+        min_sdk: z.string().nullable(),
+        target_sdk: z.string().nullable(),
+        permissions: z.array(z.string()),
+        manifest: textCoverage,
+        class_count: z.number().int().nonnegative(),
+        resource_count: z.number().int().nonnegative(),
+        signature_verification: z.literal("not_performed"),
+    }),
+    search_android_classes: z.strictObject({
+        ...common,
+        query: z.string(),
+        total_classes: z.number().int().nonnegative(),
+        matches: z.array(z.string()),
+        coverage: z.literal("complete"),
+    }),
+    inspect_android_class: z.strictObject({
+        ...common,
+        class_name: z.string(),
+        methods: z.array(method),
+        fields: z.array(z.strictObject({ name: z.string(), reported_type: z.string() })),
+        inner_classes: z.array(z.string()),
+    }),
+    inspect_android_method: z.strictObject({
+        ...common,
+        class_name: z.string(),
+        method: method,
+        overload_count: z.number().int().positive(),
+        representation: z.enum(["java", "smali"]),
+        body_status: z.enum(["available", "not_available"]),
+        fell_back: z.boolean(),
+        markers: z.array(z.string()),
+        source: textCoverage,
+    }),
+    trace_android_references: z.strictObject({
+        ...common,
+        class_name: z.string(),
+        method_name: z.string().nullable(),
+        total: z.number().int().nonnegative(),
+        references: z.array(z.strictObject({
+            kind: z.string(),
+            name: z.string(),
+            reported_full_name: z.string(),
+            containing_class: z.string(),
+            top_class: z.string(),
+            source_line: z.null(),
+            dex_offset: z.null(),
+        })),
+        coverage: z.literal("complete"),
+    }),
+};

package/dist/domain/appleAssetCatalog.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { jsonValueSchema } from "./jsonValue.js";
-import { AnalysisOutputError } from "./errors.js";
+import { AnalysisOutputError } from "./analysisErrorCore.js";
 /** Caller-controlled page bounds for compiled Apple asset metadata. */
 export const appleAssetCatalogInputSchema = z.strictObject({
     offset: z.number().int().min(0).default(0),

package/dist/domain/artifactGraph.js

@@ -42,6 +42,7 @@ const artifactFormatSchema = z.enum([
     "elf",
     "pe",
     "dos-mz",
+    "dos-com",
     "hopper",
     "analysis-database",
     "ipa",

package/dist/domain/artifactInspection.js

@@ -1,7 +1,7 @@
-import { createHash } from "node:crypto";
-import canonicalize from "canonicalize";
 import { z } from "zod";
 import { artifactInventoryResultSchema, } from "./artifactGraph.js";
+import { canonicalDigest } from "./comparisonSemantics.js";
+import { uniqueSorted } from "./canonicalOrdering.js";
 import { evidenceSchema, parseEvidence } from "./evidence.js";
 import { jsonValueSchema } from "./jsonValue.js";
 import { prefixedDigestSchema } from "./../domain/digests.js";
@@ -137,10 +137,10 @@ export const createArtifactInspection = (inventoryInput) => {
         },
         substeps: [
             {
-                substep_id: `ais_${digestCanonical({
+                substep_id: `ais_${canonicalDigest({
                     operation: "inventory_artifact",
                     evidence_id: inventoryEvidence.evidence_id,
-                })}`,
+                }, "Artifact inspection")}`,
                 operation: "inventory_artifact",
                 status: "completed",
                 evidence_id: inventoryEvidence.evidence_id,
@@ -175,7 +175,7 @@ export const createArtifactInspection = (inventoryInput) => {
     };
     return artifactInspectionResultSchema.parse({
         ...semantic,
-        inspection_id: `ai_${digestCanonical(semantic)}`,
+        inspection_id: `ai_${canonicalDigest(semantic, "Artifact inspection")}`,
     });
 };
 const parseInventoryEvidence = (input) => {
@@ -197,7 +197,10 @@ const observation = (kind, subject, value, evidenceId) => {
         value: jsonValueSchema.parse(value),
         evidence_id: evidenceId,
     };
-    return { observation_id: `aio_${digestCanonical(semantic)}`, ...semantic };
+    return {
+        observation_id: `aio_${canonicalDigest(semantic, "Artifact inspection")}`,
+        ...semantic,
+    };
 };
 const allRelationships = (inventory, evidenceId) => inventory.edges.map((edge) => {
     const semantic = {
@@ -209,7 +212,7 @@ const allRelationships = (inventory, evidenceId) => inventory.edges.map((edge) =
         evidence_id: evidenceId,
     };
     return {
-        relationship_id: `air_${digestCanonical(semantic)}`,
+        relationship_id: `air_${canonicalDigest(semantic, "Artifact inspection")}`,
         ...semantic,
     };
 });
@@ -230,7 +233,10 @@ const allHypotheses = (inventory, evidenceId) => {
             basis_evidence_ids: [evidenceId],
             limitation: "Format classification proposes a bounded follow-up; it is not semantic proof.",
         };
-        return { hypothesis_id: `aih_${digestCanonical(semantic)}`, ...semantic };
+        return {
+            hypothesis_id: `aih_${canonicalDigest(semantic, "Artifact inspection")}`,
+            ...semantic,
+        };
     });
 };
 const contradictions = (inventory, evidenceId) => inventory.integrity_contradictions.map((value) => {
@@ -242,7 +248,7 @@ const contradictions = (inventory, evidenceId) => inventory.integrity_contradict
         evidence_id: evidenceId,
     };
     return {
-        contradiction_id: `aic_${digestCanonical(semantic)}`,
+        contradiction_id: `aic_${canonicalDigest(semantic, "Artifact inspection")}`,
         ...semantic,
     };
 });
@@ -301,17 +307,13 @@ const branch = (reason, detail, nextProbe, evidenceId) => {
         next_probe: nextProbe,
         evidence_id: evidenceId,
     };
-    return { branch_id: `aib_${digestCanonical(semantic)}`, ...semantic };
+    return {
+        branch_id: `aib_${canonicalDigest(semantic, "Artifact inspection")}`,
+        ...semantic,
+    };
 };
 const inspectionCoverage = (_inventory, omissions) => {
     if (Object.values(omissions).some((count) => count > 0))
         return "truncated";
     return "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/artifactInventoryEvidence.js

@@ -1,6 +1,5 @@
-import { createHash } from "node:crypto";
-import canonicalize from "canonicalize";
 import { artifactInventoryResultSchema, } from "./artifactGraph.js";
+import { canonicalDigest, canonicalJson } from "./comparisonSemantics.js";
 import { parseEvidence } from "./evidence.js";
 import { artifactInspectionResultSchema } from "./artifactInspection.js";
 /** Parse, merge, and verify inventory Evidence pages. */
@@ -29,7 +28,8 @@ const validateInventoryPage = (inventory) => {
     assertUnique(inventory.occurrences.map(({ logical_path: path }) => path), "logical path");
     assertUnique(inventory.edges.map(({ edge_id: id }) => id), "edge ID");
     for (const node of inventory.nodes)
-        if (node.artifact_id !== `art_${digestCanonical({ sha256: node.sha256 })}`)
+        if (node.artifact_id !==
+            `art_${canonicalDigest({ sha256: node.sha256 }, "Artifact inventory")}`)
             throw new TypeError("Artifact node ID is not content-addressed");
 };
 const assembleInventorySet = (pages) => {
@@ -38,16 +38,17 @@ const assembleInventorySet = (pages) => {
     const first = pages[0];
     if (first === undefined)
         throw new TypeError("Artifact inventory requires Evidence pages");
-    const manifestJson = canonicalJson(first.inventory.manifest);
+    const manifestJson = canonicalJson(first.inventory.manifest, "Artifact inventory");
     const nodes = new Map();
     const occurrences = new Map();
     const paths = new Map();
     const edges = new Map();
     for (const page of pages) {
-        if (canonicalJson(page.inventory.manifest) !== manifestJson)
+        if (canonicalJson(page.inventory.manifest, "Artifact inventory") !==
+            manifestJson)
             throw new TypeError("Artifact inventory pages do not share one manifest");
-        if (canonicalJson(page.inventory.integrity_contradictions) !==
-            canonicalJson(first.inventory.integrity_contradictions))
+        if (canonicalJson(page.inventory.integrity_contradictions, "Artifact inventory") !==
+            canonicalJson(first.inventory.integrity_contradictions, "Artifact inventory"))
             throw new TypeError("Artifact inventory pages do not share integrity contradictions");
         for (const node of page.inventory.nodes)
             mergeExact(nodes, node.artifact_id, node, "node");
@@ -99,27 +100,27 @@ const validateCompleteInventory = (inventory) => {
         if (!nodeIds.has(contradiction.parent_artifact_id) ||
             !occurrenceIds.has(contradiction.occurrence_id))
             throw new TypeError("Integrity contradiction references a missing graph member");
-        const expectedId = `ic_${digestCanonical({
+        const expectedId = `ic_${canonicalDigest({
             root_artifact_id: inventory.manifest.root_artifact_id,
             logical_path: contradiction.logical_path,
             declared_sha256: contradiction.declared_sha256,
             observed_sha256: contradiction.observed_sha256,
-        })}`;
+        }, "Artifact inventory")}`;
         if (contradiction.contradiction_id !== expectedId)
             throw new TypeError("Integrity contradiction ID does not match its identity");
     }
-    const graphSha256 = digestCanonical({
+    const graphSha256 = canonicalDigest({
         nodes: inventory.nodes,
         occurrences: inventory.occurrences,
         edges: inventory.edges,
         integrity_contradictions: inventory.integrityContradictions,
-    });
+    }, "Artifact inventory");
     if (graphSha256 !== inventory.manifest.graph_sha256)
         throw new TypeError("Artifact graph commitment does not match its members");
-    const manifestId = `agm_${digestCanonical({
+    const manifestId = `agm_${canonicalDigest({
         root_artifact_id: inventory.manifest.root_artifact_id,
         graph_sha256: graphSha256,
-    })}`;
+    }, "Artifact inventory")}`;
     if (manifestId !== inventory.manifest.manifest_id)
         throw new TypeError("Artifact manifest ID does not match its commitment");
 };
@@ -130,12 +131,12 @@ const validateOccurrence = (occurrence, inventory, nodeIds, occurrenceIds) => {
         !occurrenceIds.has(occurrence.parent_occurrence_id))
         throw new TypeError("Artifact occurrence references a missing parent");
     const expectedId = occurrence.logical_path === "."
-        ? `occ_${digestCanonical({ root: inventory.manifest.root_artifact_id })}`
-        : `occ_${digestCanonical({
+        ? `occ_${canonicalDigest({ root: inventory.manifest.root_artifact_id }, "Artifact inventory")}`
+        : `occ_${canonicalDigest({
             root_artifact_id: inventory.manifest.root_artifact_id,
             logical_path: occurrence.logical_path,
             entry_kind: occurrence.entry_kind,
-        })}`;
+        }, "Artifact inventory")}`;
     if (occurrence.occurrence_id !== expectedId)
         throw new TypeError("Artifact occurrence ID does not match its identity");
 };
@@ -151,13 +152,14 @@ const validateEdge = (edge, nodeIds, occurrenceIds) => {
         occurrence_id: edge.occurrence_id,
         logical_path: edge.logical_path,
     };
-    if (edge.edge_id !== `edge_${digestCanonical(semantic)}`)
+    if (edge.edge_id !== `edge_${canonicalDigest(semantic, "Artifact inventory")}`)
         throw new TypeError("Artifact edge ID does not match its identity");
 };
 const mergeExact = (output, key, value, label) => {
     const previous = output.get(key);
     if (previous !== undefined &&
-        canonicalJson(previous) !== canonicalJson(value))
+        canonicalJson(previous, "Artifact inventory") !==
+            canonicalJson(value, "Artifact inventory"))
         throw new TypeError(`Artifact inventory has conflicting ${label} pages`);
     output.set(key, value);
 };
@@ -165,10 +167,3 @@ const assertUnique = (values, label) => {
     if (new Set(values).size !== values.length)
         throw new TypeError(`Artifact inventory contains a duplicate ${label}`);
 };
-const digestCanonical = (value) => createHash("sha256").update(canonicalJson(value)).digest("hex");
-const canonicalJson = (value) => {
-    const encoded = canonicalize(value);
-    if (encoded === undefined)
-        throw new TypeError("Artifact inventory could not canonicalize graph data");
-    return encoded;
-};

package/dist/domain/artifactOperationError.js

@@ -0,0 +1,16 @@
+import { AnalysisError } from "./analysisErrorBase.js";
+/** Artifact inventory or extraction failed a typed safety boundary. */
+export class ArtifactOperationError extends AnalysisError {
+    operation;
+    reason;
+    artifactDetails;
+    _tag = "ArtifactOperationError";
+    constructor(operation, reason, artifactDetails) {
+        super(artifactDetails === undefined
+            ? `Artifact ${operation} failed: ${reason}`
+            : `Artifact ${operation} failed: ${reason} at ${artifactDetails.logicalPath} (declared_sha256=${artifactDetails.declaredSha256 ?? "unavailable"}, calculated_sha256=${artifactDetails.calculatedSha256 ?? "unavailable"}, unpacked=${String(artifactDetails.unpacked)})`);
+        this.operation = operation;
+        this.reason = reason;
+        this.artifactDetails = artifactDetails;
+    }
+}

package/dist/domain/browserObservation.js

@@ -5,7 +5,9 @@ const parseExactOrigin = (value) => {
     try {
         url = new URL(value);
     }
-    catch {
+    catch (cause) {
+        // Invalid input is represented by the undefined return.
+        void cause;
         return undefined;
     }
     if ((url.protocol !== "http:" && url.protocol !== "https:") ||
@@ -44,7 +46,9 @@ export const browserEndpointSchema = z
     try {
         url = new URL(value);
     }
-    catch {
+    catch (cause) {
+        // Invalid input is reported through the zod issue.
+        void cause;
         context.addIssue({ code: "custom", message: "Invalid CDP endpoint URL" });
         return z.NEVER;
     }
@@ -122,7 +126,9 @@ export const sanitizeBrowserUrl = (value) => {
     try {
         parsed = new URL(value);
     }
-    catch {
+    catch (cause) {
+        // Unparseable input is preserved verbatim in the sanitized result.
+        void cause;
         return {
             url: value,
             origin: null,
@@ -165,7 +171,9 @@ const removeUrlUserInfo = (value, parsed) => {
             ? candidate
             : credentialFreeHref(parsed);
     }
-    catch {
+    catch (cause) {
+        // Fallback to the already-sanitized href when the candidate is invalid.
+        void cause;
         return credentialFreeHref(parsed);
     }
 };

package/dist/domain/browserObservationError.js

@@ -0,0 +1,23 @@
+import { AnalysisError } from "./analysisErrorBase.js";
+import { AnalysisCancelledError } from "./analysisErrorCore.js";
+/** A bounded passive browser observation failed at its CDP boundary. */
+export class BrowserObservationError extends AnalysisError {
+    operation;
+    reason;
+    _tag = "BrowserObservationError";
+    cleanupIncomplete;
+    cleanupResources;
+    userCategory;
+    constructor(operation, reason, options) {
+        super(`Browser observation ${operation} failed: ${reason}`, options);
+        this.operation = operation;
+        this.reason = reason;
+        this.cleanupIncomplete = reason === "cleanup_failed";
+        this.cleanupResources =
+            reason === "cleanup_failed" ? ["browser_transport"] : [];
+        this.userCategory =
+            reason === "cancelled" || options?.cause instanceof AnalysisCancelledError
+                ? "cancelled"
+                : undefined;
+    }
+}

package/dist/domain/browserScenario.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { browserScenarioActionSchema, browserScenarioBrowserSchema, browserScenarioCaptureSchema, browserScenarioEnvironmentSchema, browserScenarioSecretSchema, browserScenarioStorageSchema, browserScenarioUrlSchema, } from "./browserScenarioValues.js";
-export { browserScenarioActionSchema, browserScenarioUrlSchema, browserScenarioValueSchema, } from "./browserScenarioValues.js";
+export {} from "./browserScenarioValues.js";
 export const browserScenarioInputSchema = z.strictObject({
     browser: browserScenarioBrowserSchema.describe("Required launch/connect selection. Launch uses the selected executable and an owned temporary profile; connect uses one loopback CDP endpoint and target."),
     start_url: browserScenarioUrlSchema.describe("Required initial HTTP(S) URL. Query values must be declared separately as public literals or secret references."),

package/dist/domain/browserScenarioCapture.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { browserScenarioCompletenessSchema, browserScenarioEventSchema, browserScenarioStepSchema, } from "./browserScenarioCaptureValues.js";
-export { classifyBrowserScenarioCompleteness, browserScenarioCompletenessSchema, browserScenarioEventSchema, browserScenarioStepSchema, browserStepArtifactsSchema, captureStateSchema, } from "./browserScenarioCaptureValues.js";
+export { classifyBrowserScenarioCompleteness, browserScenarioEventSchema, browserScenarioStepSchema, browserStepArtifactsSchema, } from "./browserScenarioCaptureValues.js";
 /** Step-indexed browser scenario observation. */
 export const browserScenarioCaptureSchema = z
     .strictObject({

package/dist/domain/browserScenarioDiff.js

@@ -1,7 +1,7 @@
 import {} from "./browserScenarioCapture.js";
 import { actionState, artifactEvidenceState, captured, eventEvidenceState, eventsFor, screenshotProjection, } from "./browserScenarioDiffEvidence.js";
 import { browserScenarioDiffSchema, } from "./browserScenarioDiffValues.js";
-import { commitBrowserScenarioNormalization, digestCanonicalJson, digestNormalizedScenarioValue, } from "./browserScenarioNormalization.js";
+import { commitBrowserScenarioNormalization, digestNormalizedScenarioValue, } from "./browserScenarioNormalization.js";
 export { browserScenarioDiffSchema, compareBrowserScenariosInputSchema, } from "./browserScenarioDiffValues.js";
 /** Compare scenario steps by stable step ID and apply only committed literal rules. */
 export const compareBrowserScenarios = (input) => {

package/dist/domain/browserScenarioNormalization.js

@@ -1,5 +1,4 @@
-import { createHash } from "node:crypto";
-import canonicalize from "canonicalize";
+import { canonicalDigest } from "./comparisonSemantics.js";
 const BUILT_IN_RULES = [
     "ignore_step_elapsed_ms",
     "ignore_event_sequence",
@@ -16,17 +15,13 @@ export const commitBrowserScenarioNormalization = (input) => {
     }))
         .sort((left, right) => left.rule_id < right.rule_id ? -1 : left.rule_id > right.rule_id ? 1 : 0);
     const commitment = { built_in_rules: [...BUILT_IN_RULES], rules };
-    return { ...commitment, sha256: digestCanonicalJson(commitment) };
+    return {
+        ...commitment,
+        sha256: canonicalDigest(commitment, "Browser scenario"),
+    };
 };
 /** Digest one artifact after applying committed exact-literal rules. */
-export const digestNormalizedScenarioValue = (value, artifact, rules) => digestCanonicalJson(normalize(value, artifact, rules));
-/** Compute a canonical SHA-256 commitment for JSON-compatible domain data. */
-export const digestCanonicalJson = (value) => {
-    const encoded = canonicalize(value);
-    if (encoded === undefined)
-        throw new TypeError("Expected canonical JSON");
-    return createHash("sha256").update(encoded).digest("hex");
-};
+export const digestNormalizedScenarioValue = (value, artifact, rules) => canonicalDigest(normalize(value, artifact, rules), "Browser scenario");
 const normalize = (value, artifact, rules) => {
     if (artifact === "screenshot")
         return value;

package/dist/domain/browserScenarioValues.js

@@ -12,7 +12,9 @@ const browserScenarioBaseUrlSchema = z
     try {
         url = new URL(value);
     }
-    catch {
+    catch (cause) {
+        // Invalid input is reported through the zod issue.
+        void cause;
         context.addIssue({ code: "custom", message: "Invalid browser URL" });
         return z.NEVER;
     }