rea-agents 4.1.0 → 6.0.0

package/dist/domain/mobileApplicationInvestigation.js

@@ -1,159 +0,0 @@
-import { z } from "zod";
-/** Supported mobile artifact formats. */
-export const mobileArtifactFormatSchema = z.enum([
-    "apk",
-    "aab",
-    "ipa",
-    "dex",
-    "native_lib",
-]);
-/** Mobile platform. */
-export const mobilePlatformSchema = z.enum([
-    "android",
-    "ios",
-    "cross_platform",
-]);
-/** Android manifest entry. */
-export const androidManifestSchema = z.strictObject({
-    package_name: z.string().min(1),
-    version_name: z.string().nullable(),
-    version_code: z.number().int().nullable(),
-    min_sdk: z.number().int().nullable(),
-    target_sdk: z.number().int().nullable(),
-    permissions: z.array(z.string()).default([]),
-    activities: z.array(z.string()).default([]),
-    services: z.array(z.string()).default([]),
-    receivers: z.array(z.string()).default([]),
-    providers: z.array(z.string()).default([]),
-});
-/** iOS app manifest (Info.plist). */
-export const iosManifestSchema = z.strictObject({
-    bundle_identifier: z.string().min(1),
-    bundle_version: z.string().nullable(),
-    short_version: z.string().nullable(),
-    minimum_os_version: z.string().nullable(),
-    supported_platforms: z.array(z.string()).default([]),
-    ui_required_device_capabilities: z.array(z.string()).default([]),
-    app_permissions: z.array(z.string()).default([]),
-});
-/** Signing information. */
-export const signingInfoSchema = z.strictObject({
-    is_signed: z.boolean().default(false),
-    signer_identity: z.string().nullable(),
-    certificate_fingerprint: z.string().nullable(),
-    signature_scheme: z.string().nullable(),
-    is_debuggable: z.boolean().default(false),
-});
-/** Native library entry. */
-export const nativeLibrarySchema = z.strictObject({
-    path: z.string().min(1),
-    architecture: z.string().nullable(),
-    size: z.number().int().nonnegative(),
-    digest: z
-        .string()
-        .regex(/^[a-f0-9]{64}$/u)
-        .nullable(),
-});
-/** Resource entry within a mobile artifact. */
-export const mobileResourceSchema = z.strictObject({
-    path: z.string().min(1),
-    type: z.enum([
-        "layout",
-        "drawable",
-        "string",
-        "asset",
-        "raw",
-        "native_lib",
-        "manifest",
-        "entitlements",
-        "provisioning",
-        "other",
-    ]),
-    size: z.number().int().nonnegative(),
-});
-/** Static analysis result for a mobile artifact. */
-export const mobileArtifactManifestSchema = z.strictObject({
-    format: mobileArtifactFormatSchema,
-    platform: mobilePlatformSchema,
-    app_name: z.string().nullable(),
-    android_manifest: androidManifestSchema.nullable(),
-    ios_manifest: iosManifestSchema.nullable(),
-    signing: signingInfoSchema,
-    resources: z.array(mobileResourceSchema).default([]),
-    native_libraries: z.array(nativeLibrarySchema).default([]),
-    total_size: z.number().int().nonnegative(),
-    architectures: z.array(z.string()).default([]),
-});
-/** Detect mobile artifact format from file extension. */
-export function detectMobileFormat(path) {
-    const lower = path.toLowerCase();
-    if (lower.endsWith(".apk"))
-        return "apk";
-    if (lower.endsWith(".aab"))
-        return "aab";
-    if (lower.endsWith(".ipa"))
-        return "ipa";
-    if (lower.endsWith(".dex"))
-        return "dex";
-    if (lower.endsWith(".so") || lower.endsWith(".dylib") || lower.endsWith(".a"))
-        return "native_lib";
-    return null;
-}
-/** Detect platform from format. */
-export function detectPlatform(format) {
-    switch (format) {
-        case "apk":
-        case "aab":
-        case "dex":
-            return "android";
-        case "ipa":
-            return "ios";
-        case "native_lib":
-            return "cross_platform";
-    }
-}
-/** Classify a resource by its path. */
-export function classifyMobileResource(path) {
-    const lower = path.toLowerCase();
-    if (lower.includes("androidmanifest.xml"))
-        return "manifest";
-    if (lower.includes(".entitlements"))
-        return "entitlements";
-    if (lower.includes("provisioning") || lower.includes(".mobileprovision"))
-        return "provisioning";
-    if (lower.includes("/layout/"))
-        return "layout";
-    if (lower.includes("/drawable/") || lower.includes("/mipmap/"))
-        return "drawable";
-    if (lower.includes("/values/"))
-        return "string";
-    if (lower.includes("assets/") || lower.includes("raw/"))
-        return "asset";
-    if (lower.endsWith(".so") || lower.endsWith(".dylib"))
-        return "native_lib";
-    if (lower.endsWith(".xml"))
-        return "layout";
-    return "other";
-}
-/** Get all native libraries for a specific architecture. */
-export function nativeLibsByArchitecture(manifest, arch) {
-    return manifest.native_libraries.filter((l) => l.architecture === arch);
-}
-/** Check if an Android artifact has internet permission. */
-export function hasInternetPermission(manifest) {
-    if (!manifest.android_manifest)
-        return false;
-    return manifest.android_manifest.permissions.some((p) => p.includes("INTERNET") || p.includes("android.permission.INTERNET"));
-}
-/** Get all unique architectures across native libraries. */
-export function getAllArchitectures(manifest) {
-    const archs = new Set();
-    for (const lib of manifest.native_libraries) {
-        if (lib.architecture)
-            archs.add(lib.architecture);
-    }
-    for (const arch of manifest.architectures) {
-        archs.add(arch);
-    }
-    return [...archs];
-}

package/dist/domain/packageAnalysis.js

@@ -1,123 +0,0 @@
-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

@@ -1,197 +0,0 @@
-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),
-    /** 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 0x01c2:
-        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/processCapture.js

@@ -1,177 +0,0 @@
-import { z } from "zod";
-import { jsonValueSchema } from "./jsonValue.js";
-import { normalizationSchema } from "./processScenario.js";
-import { collectProcessCaptureIssues } from "./processCaptureValidation.js";
-export * from "./processScenario.js";
-/** Capture collection whose members participate in global observation order. */
-export const PROCESS_CAPTURE_EVENT_COLLECTIONS = [
-    "frames",
-    "rendered_frames",
-    "interaction_events",
-    "lifecycle",
-    "process_samples",
-    "filesystem_checkpoints",
-];
-const fileStateShape = {
-    path: z.string(),
-    mode: z.number().int().nonnegative(),
-    size: z.number().int().nonnegative(),
-};
-const fileStateSchema = z.discriminatedUnion("type", [
-    z.object({
-        ...fileStateShape,
-        type: z.literal("file"),
-        sha256: z
-            .string()
-            .regex(/^[a-f0-9]{64}$/u)
-            .nullable(),
-        symlink_target: z.null(),
-    }),
-    z.object({
-        ...fileStateShape,
-        type: z.literal("symlink"),
-        sha256: z.null(),
-        symlink_target: z.string(),
-    }),
-    z.object({
-        ...fileStateShape,
-        type: z.enum(["directory", "other"]),
-        sha256: z.null(),
-        symlink_target: z.null(),
-    }),
-]);
-const fileEffectSchema = z.discriminatedUnion("status", [
-    z.object({
-        path: z.string(),
-        status: z.literal("created"),
-        before: z.null(),
-        after: fileStateSchema,
-    }),
-    z.object({
-        path: z.string(),
-        status: z.literal("deleted"),
-        before: fileStateSchema,
-        after: z.null(),
-    }),
-    z.object({
-        path: z.string(),
-        status: z.enum(["modified", "unchanged"]),
-        before: fileStateSchema,
-        after: fileStateSchema,
-    }),
-]);
-/** Exact serialized shape of a process capture. */
-const processCaptureShapeSchema = z.strictObject({
-    manifest: z.strictObject({
-        rea_version: z.string().min(1),
-        provider_version: z.string().min(1),
-        platform: z.string().min(1),
-        architecture: z.string().min(1),
-        pty_backend: z.literal("node-pty"),
-        started_at: z.iso.datetime(),
-        completed_at: z.iso.datetime(),
-        scenario: z.record(z.string(), jsonValueSchema),
-        comparison_contract: z.record(z.string(), jsonValueSchema),
-        full_scenario_sha256: z.string().regex(/^[a-f0-9]{64}$/u),
-        comparison_contract_sha256: z.string().regex(/^[a-f0-9]{64}$/u),
-        executable_sha256: z.string().regex(/^[a-f0-9]{64}$/u),
-        normalization_sha256: z.string().regex(/^[a-f0-9]{64}$/u),
-    }),
-    normalization: normalizationSchema,
-    frames: z.array(z.object({
-        sequence: z.number().int().nonnegative(),
-        at_ms: z.number().int().nonnegative(),
-        data: z.string(),
-    })),
-    rendered_frames: z.array(z.object({
-        sequence: z.number().int().nonnegative(),
-        at_ms: z.number().int().nonnegative(),
-        columns: z.number().int().positive(),
-        rows: z.number().int().positive(),
-        cursor_x: z.number().int().nonnegative(),
-        cursor_y: z.number().int().nonnegative(),
-        active_buffer: z.enum(["normal", "alternate"]),
-        lines: z.array(z.string()),
-        serialized_state: z.string(),
-    })),
-    interaction_events: z.array(z.object({
-        sequence: z.number().int().nonnegative(),
-        scheduled_at_ms: z.number().int().nonnegative(),
-        dispatched_at_ms: z.number().int().nonnegative(),
-        type: z.enum(["input", "resize", "signal"]),
-        data: z.string(),
-        outcome: z.enum(["dispatched", "target_exited", "failed"]),
-    })),
-    exit: z.object({
-        code: z.number().int().nullable(),
-        signal: z.number().int().nullable(),
-        reason: z.enum(["exited", "timeout", "idle_timeout"]),
-    }),
-    settlement: z.discriminatedUnion("state", [
-        z.object({
-            state: z.literal("quiesced"),
-            elapsed_ms: z.number().int().nonnegative(),
-            cleanup_outcome: z.literal("not_required"),
-        }),
-        z.object({
-            state: z.enum(["alive_at_deadline", "unverifiable"]),
-            elapsed_ms: z.number().int().nonnegative(),
-            cleanup_outcome: z.enum(["cleaned", "failed"]),
-        }),
-    ]),
-    process_samples: z.array(z.object({
-        at_ms: z.number().int().nonnegative(),
-        pid: z.number().int().positive(),
-        parent_pid: z.number().int().nonnegative(),
-        command: z.string(),
-        process_group_id: z.number().int().positive().nullable(),
-        session_id: z.number().int().nonnegative().nullable(),
-    })),
-    filesystem_checkpoints: z.array(z.object({
-        name: z.enum(["before", "after_settlement"]),
-        at_ms: z.number().int().nonnegative(),
-        files: z.array(fileStateSchema),
-        effects: z.array(fileEffectSchema),
-        truncated: z.boolean(),
-    })),
-    event_journal: z
-        .array(z.object({
-        capture_order: z.number().int().nonnegative(),
-        collection: z.enum(PROCESS_CAPTURE_EVENT_COLLECTIONS),
-        index: z.number().int().nonnegative(),
-    }))
-        .default([]),
-    files_before: z.array(fileStateSchema),
-    files_after: z.array(fileStateSchema),
-    filesystem_effects: z.array(fileEffectSchema),
-    truncated: z.boolean(),
-    limitations: z.array(z.string()),
-    residual_unknowns: z.array(z.object({
-        scope: z.enum([
-            "terminal",
-            "interaction",
-            "exit",
-            "process",
-            "filesystem",
-            "cleanup",
-            "network",
-            "environment",
-        ]),
-        reason: z.string(),
-    })),
-    cleanup: z.object({
-        owned_process_group: z.literal("verified"),
-        temporary_root: z.literal("removed"),
-    }),
-});
-/** Exact serialized shape plus all process-capture semantic invariants. */
-export const processCaptureSchema = processCaptureShapeSchema.superRefine((capture, context) => {
-    for (const issue of collectProcessCaptureIssues(capture))
-        context.addIssue({
-            code: "custom",
-            path: issue.path.split("."),
-            message: issue.message,
-        });
-});
-export { parseProcessCapture } from "./processCaptureParsing.js";
-export { compareProcessCaptures, comparisonStatusSchema, deriveProcessComparisonStatus, PROCESS_COMPARISON_DIMENSIONS, processCaptureComparisonSchema, } from "./processComparison.js";

package/dist/domain/processCaptureParsing.js

@@ -1,21 +0,0 @@
-import { processCaptureSchema, } from "./processCapture.js";
-const verifiedCaptures = new WeakSet();
-const isVerifiedCapture = (capture) => verifiedCaptures.has(capture);
-const attachProof = (capture) => {
-    verifiedCaptures.add(capture);
-    if (isVerifiedCapture(capture))
-        return capture;
-    throw new TypeError("Process Capture proof ownership failed");
-};
-/** Parse unknown input and reject invalid commitments or semantics. */
-export const parseProcessCapture = (input) => {
-    const parsed = processCaptureSchema.safeParse(input);
-    if (parsed.success)
-        return attachProof(parsed.data);
-    const issues = parsed.error.issues.flatMap((issue) => issue.code === "custom"
-        ? [{ path: issue.path.join("."), message: issue.message }]
-        : []);
-    if (issues.length > 0)
-        throw new TypeError(`Invalid process capture: ${issues.map(({ path, message }) => `${path}: ${message}`).join("; ")}`);
-    throw parsed.error;
-};