rea-agents 2.5.0 → 3.1.0

package/dist/domain/nodeRuntimeCharacterization.js

@@ -1,24 +1,25 @@
 import { z } from "zod";
-import { controlledReplayInputSchema, controlledReplayOutputSchema, } from "./javascriptReplay.js";
+import { controlledReplayExecutionOutputSchema, controlledReplayPlanInputSchema, controlledReplayPlanOutputSchema, } from "./javascriptReplay.js";
 import { javascriptExportInstrumentationInputSchema, javascriptExportTransformationManifestSchema, } from "./javascriptExportInstrumentation.js";
 import { runtimeCharacterizationPlanSchema } from "./runtimeCharacterization.js";
 import { evidenceRecordSchema } from "./evidence.js";
 const digestSchema = z.string().regex(/^[a-f0-9]{64}$/u);
+const nodeCharacterizationExpectedEffectSchema = z.enum([
+    "pure",
+    "observation-only",
+]);
+const nodeRuntimeCharacterizationPlanSchema = runtimeCharacterizationPlanSchema.extend({
+    expected_effect: nodeCharacterizationExpectedEffectSchema,
+});
 export const nodeCharacterizationPreparationInputSchema = z
     .strictObject({
     preparation_approved: z.literal(true),
     selected_alias: z.string().min(1).max(200),
-    expected_effect: z.enum(["pure", "observation-only"]),
+    expected_effect: nodeCharacterizationExpectedEffectSchema,
     instrumentation: javascriptExportInstrumentationInputSchema,
-    replay: controlledReplayInputSchema,
+    replay: controlledReplayPlanInputSchema,
 })
     .superRefine((input, context) => {
-    if (input.replay.mode !== "plan")
-        context.addIssue({
-            code: "custom",
-            path: ["replay", "mode"],
-            message: "Characterization preparation requires replay plan mode",
-        });
     const selected = input.replay.left.modules.filter(({ alias }) => alias === input.selected_alias);
     if (selected.length !== 1 ||
         selected[0]?.path !== input.instrumentation.artifact_path ||
@@ -50,17 +51,17 @@ export const nodeCharacterizationExecutionInputSchema = z.strictObject({
 export const nodeCharacterizationPreparationOutputSchema = z.strictObject({
     schema_version: z.literal(1),
     phase: z.literal("preparation"),
-    plan: runtimeCharacterizationPlanSchema,
+    plan: nodeRuntimeCharacterizationPlanSchema,
     transformation: javascriptExportTransformationManifestSchema,
     transformation_evidence: evidenceRecordSchema,
-    replay: controlledReplayOutputSchema,
+    replay: controlledReplayPlanOutputSchema,
 });
 export const nodeCharacterizationExecutionOutputSchema = z.strictObject({
     schema_version: z.literal(1),
     phase: z.literal("execution"),
-    plan: runtimeCharacterizationPlanSchema,
+    plan: nodeRuntimeCharacterizationPlanSchema,
     transformation: javascriptExportTransformationManifestSchema,
     transformation_evidence: evidenceRecordSchema,
     evidence: evidenceRecordSchema,
-    replay: controlledReplayOutputSchema,
+    replay: controlledReplayExecutionOutputSchema,
 });

package/dist/domain/objcSwiftMetadata.js

@@ -0,0 +1,150 @@
+import { z } from "zod";
+/** Objective-C method type. */
+export const objcMethodTypeSchema = z.enum([
+    "instance",
+    "class",
+    "ivar_getter",
+    "ivar_setter",
+]);
+/** Objective-C property attribute. */
+export const objcPropertyAttributeSchema = z.strictObject({
+    name: z.string().min(1),
+    value: z.string(),
+    is_weak: z.boolean().default(false),
+    is_atomic: z.boolean().default(false),
+    is_copy: z.boolean().default(false),
+    is_strong: z.boolean().default(false),
+});
+/** Objective-C method metadata. */
+export const objcMethodSchema = z.strictObject({
+    selector: z.string().min(1),
+    method_type: objcMethodTypeSchema,
+    address: z.number().int().nullable(),
+    is_required: z.boolean().default(false),
+    is_optional: z.boolean().default(false),
+});
+/** Objective-C property metadata. */
+export const objcPropertySchema = z.strictObject({
+    name: z.string().min(1),
+    type_encoding: z.string().nullable(),
+    attributes: z.array(objcPropertyAttributeSchema).default([]),
+    is_readonly: z.boolean().default(false),
+    getter: z.string().nullable(),
+    setter: z.string().nullable(),
+});
+/** Objective-C protocol metadata. */
+export const objcProtocolSchema = z.strictObject({
+    name: z.string().min(1),
+    methods: z.array(objcMethodSchema).default([]),
+    optional_methods: z.array(objcMethodSchema).default([]),
+    properties: z.array(objcPropertySchema).default([]),
+});
+/** Objective-C class metadata. */
+export const objcClassSchema = z.strictObject({
+    name: z.string().min(1),
+    super_class: z.string().nullable(),
+    is_meta_class: z.boolean().default(false),
+    is_root_class: z.boolean().default(false),
+    methods: z.array(objcMethodSchema).default([]),
+    properties: z.array(objcPropertySchema).default([]),
+    protocols: z.array(z.string()).default([]),
+    ivar_count: z.number().int().nonnegative().default(0),
+    instance_size: z.number().int().nonnegative().nullable(),
+});
+/** Swift declaration kind. */
+export const swiftDeclKindSchema = z.enum([
+    "class",
+    "struct",
+    "enum",
+    "protocol",
+    "extension",
+    "actor",
+    "global_var",
+    "global_func",
+]);
+/** Swift access level. */
+export const swiftAccessLevelSchema = z.enum([
+    "private",
+    "fileprivate",
+    "internal",
+    "public",
+    "open",
+]);
+/** Swift declaration metadata. */
+export const swiftDeclSchema = z.strictObject({
+    kind: swiftDeclKindSchema,
+    name: z.string().min(1),
+    module: z.string().nullable(),
+    access_level: swiftAccessLevelSchema.default("internal"),
+    super_class: z.string().nullable(),
+    protocols: z.array(z.string()).default([]),
+    is_final: z.boolean().default(false),
+    is_required: z.boolean().default(false),
+    is_convenience_init: z.boolean().default(false),
+    is_override: z.boolean().default(false),
+});
+/** Database save/read operation type. */
+export const dbOperationSchema = z.enum([
+    "save",
+    "readback",
+    "open_database",
+    "close_database",
+    "export",
+    "import",
+]);
+/** Database save operation result. */
+export const dbSaveResultSchema = z.strictObject({
+    operation: dbOperationSchema,
+    succeeded: z.boolean(),
+    preserved_names: z.number().int().nonnegative().default(0),
+    preserved_comments: z.number().int().nonnegative().default(0),
+    preserved_bookmarks: z.number().int().nonnegative().default(0),
+    database_path: z.string().nullable(),
+    error: z.string().nullable(),
+});
+/** Result of deeper ObjC/Swift metadata extraction. */
+export const objcSwiftMetadataSchema = z.strictObject({
+    objc_classes: z.array(objcClassSchema).default([]),
+    objc_protocols: z.array(objcProtocolSchema).default([]),
+    swift_decls: z.array(swiftDeclSchema).default([]),
+    db_save_result: dbSaveResultSchema.nullable(),
+});
+/** Check if a selector name looks like a getter. */
+export function isGetterSelector(selector) {
+    return /^[a-z][a-zA-Z0-9_]*$/u.test(selector) && !selector.includes(":");
+}
+/** Check if a selector name looks like a setter. */
+export function isSetterSelector(selector) {
+    return selector.startsWith("set") && selector.endsWith(":");
+}
+/** Extract property name from a getter/setter selector. */
+export function propertyNameFromSelector(selector) {
+    if (isSetterSelector(selector)) {
+        const inner = selector.slice(3, -1);
+        return inner.charAt(0).toLowerCase() + inner.slice(1);
+    }
+    if (isGetterSelector(selector)) {
+        return selector;
+    }
+    return null;
+}
+/** Count ObjC methods by type. */
+export function countMethodsByType(methods) {
+    return {
+        instance: methods.filter((m) => m.method_type === "instance").length,
+        class: methods.filter((m) => m.method_type === "class").length,
+        ivar_getter: methods.filter((m) => m.method_type === "ivar_getter").length,
+        ivar_setter: methods.filter((m) => m.method_type === "ivar_setter").length,
+    };
+}
+/** Get all Swift declarations of a specific kind. */
+export function swiftDeclsByKind(decls, kind) {
+    return decls.filter((d) => d.kind === kind);
+}
+/** Check if a database save preserved all expected items. */
+export function isDbSaveComplete(result, expectedNames, expectedComments, expectedBookmarks) {
+    return (result.succeeded &&
+        result.preserved_names >= expectedNames &&
+        result.preserved_comments >= expectedComments &&
+        result.preserved_bookmarks >= expectedBookmarks);
+}

package/dist/domain/packageAnalysis.js

@@ -0,0 +1,123 @@
+import { z } from "zod";
+/** Supported Windows package formats. */
+export const packageFormatSchema = z.enum(["msix", "msi", "appx"]);
+/** A resource entry within a package. */
+export const packageResourceSchema = z.strictObject({
+    /** Resource path within the package. */
+    path: z.string().min(1),
+    /** Resource type. */
+    type: z.enum([
+        "manifest",
+        "icon",
+        "configuration",
+        "certificate",
+        "executable",
+        "library",
+        "data",
+        "other",
+    ]),
+    /** Size in bytes. */
+    size: z.number().int().nonnegative(),
+    /** SHA-256 digest. */
+    digest: z
+        .string()
+        .regex(/^[a-f0-9]{64}$/u)
+        .nullable(),
+});
+/** Digital signature information. */
+export const digitalSignatureSchema = z.strictObject({
+    /** Whether the package is signed. */
+    is_signed: z.boolean(),
+    /** Signer subject name. */
+    signer_subject: z.string().nullable(),
+    /** Certificate thumbprint. */
+    certificate_thumbprint: z.string().nullable(),
+    /** Whether the signature is valid. */
+    is_valid: z.boolean().default(false),
+    /** Whether the signature is timestamped. */
+    is_timestamped: z.boolean().default(false),
+    /** Timestamp signer if present. */
+    timestamp_signer: z.string().nullable(),
+});
+/** A Windows package manifest for static analysis. */
+export const packageManifestSchema = z.strictObject({
+    /** Package format. */
+    format: packageFormatSchema,
+    /** Package identity name. */
+    name: z.string().min(1),
+    /** Package publisher. */
+    publisher: z.string().nullable(),
+    /** Package version. */
+    version: z.string().nullable(),
+    /** Architecture. */
+    architecture: z.enum(["x86", "x64", "arm", "arm64", "neutral", "unknown"]),
+    /** Package resources. */
+    resources: z.array(packageResourceSchema).default([]),
+    /** Digital signature. */
+    signature: digitalSignatureSchema,
+    /** Whether the package is a framework. */
+    is_framework: z.boolean().default(false),
+    /** Package dependencies. */
+    dependencies: z.array(z.string()).default([]),
+    /** Capabilities declared in the manifest. */
+    capabilities: z.array(z.string()).default([]),
+});
+/** Detect package format from file extension. */
+export function detectPackageFormat(path) {
+    const lower = path.toLowerCase();
+    if (lower.endsWith(".msix"))
+        return "msix";
+    if (lower.endsWith(".msi"))
+        return "msi";
+    if (lower.endsWith(".appx"))
+        return "appx";
+    return null;
+}
+/** Check if a resource path looks like a manifest. */
+export function isManifestResource(path) {
+    const lower = path.toLowerCase();
+    return (lower.includes("appxmanifest.xml") ||
+        lower.includes("appxmanifest") ||
+        lower.includes("manifest.xml") ||
+        lower.endsWith("_manifest.xml"));
+}
+/** Check if a resource path looks like a configuration file. */
+export function isConfigurationResource(path) {
+    const lower = path.toLowerCase();
+    return (lower.endsWith(".xml") ||
+        lower.endsWith(".json") ||
+        lower.endsWith(".ini") ||
+        lower.endsWith(".config"));
+}
+/** Classify a resource by its path. */
+export function classifyResource(path) {
+    if (isManifestResource(path))
+        return "manifest";
+    const lower = path.toLowerCase();
+    if (lower.endsWith(".ico") ||
+        lower.endsWith(".png") ||
+        lower.endsWith(".jpg") ||
+        lower.endsWith(".jpeg"))
+        return "icon";
+    if (isConfigurationResource(path))
+        return "configuration";
+    if (lower.endsWith(".cer") ||
+        lower.endsWith(".pfx") ||
+        lower.endsWith(".p12"))
+        return "certificate";
+    if (lower.endsWith(".exe") || lower.endsWith(".dll"))
+        return lower.endsWith(".exe") ? "executable" : "library";
+    return "other";
+}
+/** Get all resources of a specific type. */
+export function resourcesByType(manifest, type) {
+    return manifest.resources.filter((r) => r.type === type);
+}
+/** Get the total size of all resources. */
+export function totalResourceSize(manifest) {
+    return manifest.resources.reduce((sum, r) => sum + r.size, 0);
+}
+/** Check if a package has a valid signature. */
+export function hasValidSignature(manifest) {
+    return manifest.signature.is_signed && manifest.signature.is_valid;
+}

package/dist/domain/peInspection.js

@@ -0,0 +1,196 @@
+import { z } from "zod";
+/** PE/COFF section characteristics flags. */
+export const sectionCharacteristicsSchema = z.object({
+    /** Section contains executable code. */
+    has_code: z.boolean().default(false),
+    /** Section contains initialized data. */
+    has_initialized_data: z.boolean().default(false),
+    /** Section contains uninitialized data. */
+    has_uninitialized_data: z.boolean().default(false),
+    /** Section can be read. */
+    readable: z.boolean().default(false),
+    /** Section can be written. */
+    writable: z.boolean().default(false),
+    /** Section can be executed. */
+    executable: z.boolean().default(false),
+});
+/** PE/COFF section header. */
+export const peSectionSchema = z.strictObject({
+    name: z.string().min(1),
+    virtual_size: z.number().int().nonnegative(),
+    virtual_address: z.number().int().nonnegative(),
+    raw_size: z.number().int().nonnegative(),
+    raw_offset: z.number().int().nonnegative(),
+    characteristics: sectionCharacteristicsSchema,
+});
+/** PE import entry. */
+export const peImportSchema = z.strictObject({
+    dll: z.string().min(1),
+    function_name: z.string().min(1),
+    ordinal: z.number().int().nullable(),
+    is_delay_import: z.boolean().default(false),
+});
+/** PE export entry. */
+export const peExportSchema = z.strictObject({
+    name: z.string().min(1),
+    ordinal: z.number().int().nonnegative(),
+    rva: z.number().int().nonnegative(),
+    forwarder: z.string().nullable(),
+});
+/** PE/COFF resource entry. */
+export const peResourceSchema = z.strictObject({
+    type: z.string().min(1),
+    name: z.string().nullable(),
+    language: z.number().int().nullable(),
+    rva: z.number().int().nonnegative(),
+    size: z.number().int().nonnegative(),
+});
+/** PE debug directory entry. */
+export const peDebugEntrySchema = z.strictObject({
+    type: z.string().min(1),
+    rva: z.number().int().nonnegative(),
+    size: z.number().int().nonnegative(),
+    /** PDB GUID if this is a CodeView entry. */
+    pdb_guid: z.string().nullable(),
+    /** PDB age if this is a CodeView entry. */
+    pdb_age: z.number().int().nullable(),
+    /** PDB path if this is a CodeView entry. */
+    pdb_path: z.string().nullable(),
+});
+/** TLS callback entry. */
+export const peTlsCallbackSchema = z.strictObject({
+    callback_rva: z.number().int().nonnegative(),
+    index: z.number().int().nonnegative(),
+});
+/** Architecture/machine type. */
+export const peMachineTypeSchema = z.enum([
+    "x86",
+    "x64",
+    "arm",
+    "arm64",
+    "ia64",
+    "unknown",
+]);
+/** PE/COFF manifest for static inspection. */
+export const peManifestSchema = z.strictObject({
+    /** DOS header magic. */
+    dos_magic: z.literal(0x5a4d),
+    /** PE signature. */
+    pe_signature: z.literal(0x00004550),
+    /** Machine type. */
+    machine: peMachineTypeSchema,
+    /** Number of sections. */
+    number_of_sections: z.number().int().positive(),
+    /** Timestamp from the COFF header. */
+    timestamp: z.number().int().nullable(),
+    /** PE characteristics flags. */
+    is_dll: z.boolean().default(false),
+    is_executable: z.boolean().default(false),
+    is_console: z.boolean().default(true),
+    /** Entry point RVA. */
+    entry_point: z.number().int().nonnegative(),
+    /** Image base. */
+    image_base: z.number().int().nonnegative(),
+    /** Section alignment. */
+    section_alignment: z.number().int().positive(),
+    /** Subsystem version. */
+    subsystem_version: z.string().nullable(),
+    /** Sections. */
+    sections: z.array(peSectionSchema).min(0).max(96),
+    /** Imports. */
+    imports: z.array(peImportSchema).default([]),
+    /** Exports. */
+    exports: z.array(peExportSchema).default([]),
+    /** Resources. */
+    resources: z.array(peResourceSchema).default([]),
+    /** Debug directory entries. */
+    debug_entries: z.array(peDebugEntrySchema).default([]),
+    /** TLS callbacks. */
+    tls_callbacks: z.array(peTlsCallbackSchema).default([]),
+    /** Relocations count (not all entries). */
+    relocations_count: z.number().int().nonnegative().default(0),
+    /** Image file characteristics. */
+    image_characteristics: z.array(z.string()).default([]),
+});
+/** Parse machine type from COFF machine field. */
+export function parseMachineType(machine) {
+    switch (machine) {
+        case 0x014c:
+            return "x86";
+        case 0x8664:
+            return "x64";
+        case 0x01c0:
+        case 0x01c4:
+            return "arm";
+        case 0xaa64:
+            return "arm64";
+        case 0x0200:
+            return "ia64";
+        default:
+            return "unknown";
+    }
+}
+/** Parse section characteristics flags. */
+export function parseSectionCharacteristics(characteristics) {
+    const IMAGE_SCN_CNT_CODE = 0x00000020;
+    const IMAGE_SCN_CNT_INITIALIZED_DATA = 0x00000040;
+    const IMAGE_SCN_CNT_UNINITIALIZED_DATA = 0x00000080;
+    const IMAGE_SCN_MEM_READ = 0x40000000;
+    const IMAGE_SCN_MEM_WRITE = 0x80000000;
+    const IMAGE_SCN_MEM_EXECUTE = 0x20000000;
+    return {
+        has_code: (characteristics & IMAGE_SCN_CNT_CODE) !== 0,
+        has_initialized_data: (characteristics & IMAGE_SCN_CNT_INITIALIZED_DATA) !== 0,
+        has_uninitialized_data: (characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA) !== 0,
+        readable: (characteristics & IMAGE_SCN_MEM_READ) !== 0,
+        writable: (characteristics & IMAGE_SCN_MEM_WRITE) !== 0,
+        executable: (characteristics & IMAGE_SCN_MEM_EXECUTE) !== 0,
+    };
+}
+/** Parse image characteristics flags. */
+export function parseImageCharacteristics(characteristics) {
+    const IMAGE_DLL = 0x2000;
+    const IMAGE_EXECUTABLE = 0x0002;
+    const IMAGE_CONSOLE = 0x0003;
+    const flags = [];
+    if (characteristics & IMAGE_DLL)
+        flags.push("DLL");
+    if (characteristics & IMAGE_EXECUTABLE)
+        flags.push("Executable");
+    if ((characteristics & 0x0000000f) === IMAGE_CONSOLE)
+        flags.push("Console");
+    return flags;
+}
+/** Parse a PE debug directory type. */
+export function parseDebugType(type) {
+    switch (type) {
+        case 0:
+            return "UNKNOWN";
+        case 1:
+            return "COFF";
+        case 2:
+            return "CODEVIEW";
+        case 3:
+            return "POGO";
+        case 4:
+            return "MISC";
+        default:
+            return "UNKNOWN";
+    }
+}
+/** Check if a PE manifest has PDB debug info. */
+export function hasPdbInfo(manifest) {
+    return manifest.debug_entries.some((e) => e.pdb_guid !== null && e.pdb_path !== null);
+}
+/** Get all imported DLLs from a PE manifest. */
+export function getImportedDlls(manifest) {
+    return [...new Set(manifest.imports.map((i) => i.dll))];
+}
+/** Get all exported function names from a PE manifest. */
+export function getExportedFunctions(manifest) {
+    return manifest.exports.map((e) => e.name);
+}
+/** Count executable sections. */
+export function countExecutableSections(manifest) {
+    return manifest.sections.filter((s) => s.characteristics.executable).length;
+}

package/dist/domain/processCaptureReactiveValidation.js

@@ -118,6 +118,8 @@ const replayTransitions = (scenario, run, observations, require) => {
         while ((run.controls[controlIndex]?.after_capture_order ??
             Number.MAX_SAFE_INTEGER) < observation.capture_order) {
             const control = run.controls[controlIndex];
+            if (control === undefined)
+                break;
             advanceControl(control, controlIndex);
             controlIndex += 1;
         }
@@ -125,6 +127,8 @@ const replayTransitions = (scenario, run, observations, require) => {
     }
     for (; controlIndex < run.controls.length; controlIndex += 1) {
         const control = run.controls[controlIndex];
+        if (control === undefined)
+            break;
         advanceControl(control, controlIndex);
     }
     require(transitionIndex ===
@@ -141,10 +145,11 @@ const validateControls = (run, observations, require) => {
         require(control.sequence ===
             index, `reactive_run.controls[${String(index)}].sequence`, "reactive control sequence must be contiguous");
         require(admittedOrders.has(control.after_capture_order), `reactive_run.controls[${String(index)}].after_capture_order`, "reactive control cutoff must identify the last admitted observation");
+        const previous = run.controls.at(index - 1);
         require(index === 0 ||
-            control.after_capture_order >=
-                run.controls[index - 1]
-                    .after_capture_order, `reactive_run.controls[${String(index)}].after_capture_order`, "reactive control cutoffs must be ordered");
+            (previous !== undefined &&
+                control.after_capture_order >=
+                    previous.after_capture_order), `reactive_run.controls[${String(index)}].after_capture_order`, "reactive control cutoffs must be ordered");
     }
 };
 /** Validate one capture's reactive journal by replaying the production reducer. */

package/dist/domain/processCaptureValidation.js

@@ -1,7 +1,11 @@
 import { validateProcessCaptureReactiveRun } from "./processCaptureReactiveValidation.js";
 import { replayMachineSchema } from "./replayMachine.js";
 import { digestProcessCommitment } from "./processScenario.js";
-const orderedTimestamps = (values) => values.every((value, index) => index === 0 || value.at_ms >= values[index - 1].at_ms);
+const orderedTimestamps = (values) => values.every((value, index) => {
+    const previous = values[index - 1];
+    return previous === undefined || value.at_ms >= previous.at_ms;
+});
+const transitionsAreContiguous = (previous, current) => previous !== undefined && previous.state_after === current.state_before;
 const validateCommitments = (capture, require) => {
     const { manifest } = capture;
     require(manifest.scenario.executable_sha256 ===
@@ -192,9 +196,9 @@ const validateReplayEvents = (capture, require) => {
         if (index === 0)
             require(transition.state_before ===
                 machine?.initial_state, "replay_transitions", "first replay transition does not start at the declared initial state");
+        const previous = capture.replay_transitions[index - 1];
         if (index > 0)
-            require(capture.replay_transitions[index - 1].state_after ===
-                transition.state_before, "replay_transitions", "replay transition states are not contiguous");
+            require(transitionsAreContiguous(previous, transition), "replay_transitions", "replay transition states are not contiguous");
     }
 };
 /** Recompute v4 commitments and cross-field invariants without side effects. */

package/dist/domain/processComparison.js

@@ -1,3 +1,4 @@
+import canonicalize from "canonicalize";
 import { z } from "zod";
 import { validateProcessCapture } from "./processCapture.js";
 import { jsonValueSchema } from "./jsonValue.js";
@@ -97,6 +98,10 @@ const filesystemObservations = (capture) => [
         effects: capture.filesystem_effects,
     },
 ];
+const sameJsonValue = (left, right) => {
+    const encodedLeft = canonicalize(left);
+    return encodedLeft !== undefined && encodedLeft === canonicalize(right);
+};
 /** Canonical observations for one process-comparison dimension. */
 export const processDimensionObservations = (capture, dimension) => {
     switch (dimension) {
@@ -117,7 +122,7 @@ export const processDimensionObservations = (capture, dimension) => {
     }
 };
 const classifyCollection = (left, right) => {
-    if (JSON.stringify(left) === JSON.stringify(right))
+    if (sameJsonValue(left, right))
         return "unchanged";
     if (left.length === 0)
         return "added";
@@ -141,7 +146,7 @@ const firstCollectionDivergence = (dimension, left, right) => {
     for (let index = 0; index < length; index += 1) {
         const leftValue = left[index] ?? null;
         const rightValue = right[index] ?? null;
-        if (JSON.stringify(leftValue) === JSON.stringify(rightValue))
+        if (sameJsonValue(leftValue, rightValue))
             continue;
         return {
             status: "found",
@@ -168,8 +173,9 @@ const assertComparable = (left, right, options) => {
         ...validateProcessCapture(left),
         ...validateProcessCapture(right),
     ];
-    if (invalid.length > 0)
-        throw new TypeError(`Invalid Process Capture v4: ${invalid[0].path}`);
+    const firstInvalid = invalid.at(0);
+    if (firstInvalid !== undefined)
+        throw new TypeError(`Invalid Process Capture v4: ${firstInvalid.path}`);
     if (left.schema_version !== right.schema_version ||
         left.manifest.comparison_contract_sha256 !==
             right.manifest.comparison_contract_sha256)
@@ -239,8 +245,7 @@ const compareDimensions = (left, right, sameNormalization) => {
         interaction: classify("interaction", left.interaction_events, right.interaction_events),
         exit: hasUnknown(left, "exit") || hasUnknown(right, "exit")
             ? "unknown"
-            : JSON.stringify({ exit: left.exit, settlement: left.settlement }) ===
-                JSON.stringify({ exit: right.exit, settlement: right.settlement })
+            : sameJsonValue({ exit: left.exit, settlement: left.settlement }, { exit: right.exit, settlement: right.settlement })
                 ? "unchanged"
                 : "changed",
         filesystem: classify("filesystem", filesystemObservations(left), filesystemObservations(right)),
@@ -266,7 +271,7 @@ export const compareProcessCaptures = (left, right, options = {}) => {
                 trace: compareProcessTraces(left, right, options.traceSpecification),
             };
     }
-    const sameNormalization = JSON.stringify(left.normalization) === JSON.stringify(right.normalization);
+    const sameNormalization = sameJsonValue(left.normalization, right.normalization);
     const exactDimensions = compareDimensions(left, right, sameNormalization);
     const trace = options.traceSpecification === undefined
         ? undefined

package/dist/domain/processObservation.js

@@ -52,14 +52,13 @@ export const createProcessObservation = (input) => ({
 const atMilliseconds = (value) => {
     if (typeof value !== "object" || value === null)
         return null;
-    for (const name of ["at_ms", "dispatched_at_ms"])
-        if (name in value) {
-            const candidate = value[name];
-            if (typeof candidate === "number" && Number.isSafeInteger(candidate))
-                return candidate;
-        }
+    if ("at_ms" in value && isSafeMillisecond(value.at_ms))
+        return value.at_ms;
+    if ("dispatched_at_ms" in value && isSafeMillisecond(value.dispatched_at_ms))
+        return value.dispatched_at_ms;
     return null;
 };
+const isSafeMillisecond = (value) => typeof value === "number" && Number.isSafeInteger(value);
 /** Derive the stable capture-local identity for one normalized observation. */
 export const processObservationSubject = (source, value) => {
     if (typeof value !== "object" || value === null || Array.isArray(value))